Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity ^0.5.0;

import "./RHC.sol";

contract Crowdsale {

  /// @dev represents a round of token sale
  struct Round {
    /// @dev price per token for every token
    uint tokenPrice;
    /// @dev total number of tokens available in the round
    uint capacityLeft;
  }

  /// @notice event is raised when a token sale occurs
  /// @param amountSent amount of money sent by the purchaser
  /// @param amountReturned amount of money returned to the purchaser in case amount sent was not exact
  /// @param buyer the address which purchased the tokens
  event Sale(uint amountSent, uint amountReturned, uint tokensSold, address buyer);

  /// @notice raised when all tokens are sold out
  event SaleCompleted();

  /// @notice raised when a round completes and the next round starts
  /// @param oldTokenPrice previous price per token
  /// @param newTokenPrice new price per token
  event RoundChanged(uint oldTokenPrice, uint newTokenPrice);

  /// @dev information about rounds of fundraising in the crowdsale
  Round[] private _rounds;
  uint8 private _currentRound;

  /// @notice where the contract wires funds in exchange for tokens
  address payable private wallet;

  /// @notice a refenence to the RHC token being sold
  RHC public token;

  /// @notice reports whether the sale is still open
  bool public isSaleOpen;

  /// @dev how much wei has been raised so far
  uint public weiRaised;

  /// @dev how many tokens have been sold so far
  uint public tokensSold;

  /// @notice creates the crowdsale. Only intended to be used by Robinhood team.
  constructor(address payable targetWallet, uint[] memory roundPrices, uint[] memory roundCapacities) public {
    require(roundPrices.length == roundCapacities.length, "Equal number of round parameters must be specified");
    require(roundPrices.length >= 1, "Crowdsale must have at least one round");
    require(roundPrices.length < 10, "Rounds are limited to 10 at most");

    // store rounds
    _currentRound = 0;
    for (uint i = 0; i < roundPrices.length; i++) {
      _rounds.push(Round(roundPrices[i], roundCapacities[i]));
    }

    wallet = targetWallet;
    isSaleOpen = true;
    weiRaised = 0;
    tokensSold = 0;

    // Create token with this contract as the owner
    token = new RHC(address(this));

    // add target wallet as an additional owner
    token.addAdmin(wallet);
  }

  function() external payable {
    uint amount = msg.value;
    address payable buyer = msg.sender;
    require(amount > 0, "must send money to get tokens");
    require(buyer != address(0), "can't send from address 0");
    require(isSaleOpen, "sale must be open in order to purchase tokens");

    (uint tokenCount, uint change) = calculateTokenCount(amount);

    // if insufficient money is sent, return the buyer's mone
    if (tokenCount == 0) {
      buyer.transfer(change);
      return;
    }

    // this is how much of the money will be consumed by this token purchase
    uint acceptedFunds = amount - change;

    // forward funds to owner
    wallet.transfer(acceptedFunds);

    // return left over (unused) funds back to the sender
    buyer.transfer(change);

    // assign tokens to whoever is purchasing
    token.issue(buyer, tokenCount);

    // update state tracking how much wei has been raised so far
    weiRaised += acceptedFunds;
    tokensSold += tokenCount;

    updateRounds(tokenCount);

    emit Sale(amount, change, tokenCount, buyer);
  }

  /// @notice given an amount of money returns how many tokens the money will result in with the
  /// current round's pricing
  function calculateTokenCount(uint money) public view returns (uint count, uint change) {
    require(isSaleOpen, "sale is no longer open and tokens can't be purchased");

    // get current token price
    uint price = _rounds[_currentRound].tokenPrice;
    uint capacityLeft = _rounds[_currentRound].capacityLeft;

    // money sent must be bigger than or equal the price, otherwise, no purchase is necessary
    if (money < price) {
      // return all the money
      return (0, money);
    }

    count = money / price;
    change = money % price;

    // Ensure there's sufficient capacity in the current round. If the user wishes to
    // purchase more, they can send money again to purchase tokens at the next round
    if (count > capacityLeft) {
      change += price * (count - capacityLeft);
      count = capacityLeft;
    }

    return (count, change);
  }

  /// increases the round or closes the sale if tokens are sold out
  function updateRounds(uint tokens) private {
    Round storage currentRound = _rounds[_currentRound];
    currentRound.capacityLeft -= tokens;

    if (currentRound.capacityLeft <= 0) {
      if (_currentRound == _rounds.length - 1) {
        isSaleOpen = false;
        emit SaleCompleted();
      } else {
        _currentRound++;
        emit RoundChanged(currentRound.tokenPrice, _rounds[_currentRound].tokenPrice);
      }
    }
  }
}

pragma solidity ^0.5.0;

/// ERC20 interface, as defined by Ethereum Improvement Proposals,
/// see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
contract EIP20 {
    /// this automatically generates the totalSupply() getter required by the ERC20 interface
    /// since it's a public parameter
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) public view returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns (bool success);

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of tokens to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) public returns (bool success);

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);

    /// MUST trigger when tokens are transferred, including zero value transfers.
    /// A token contract which creates new tokens SHOULD trigger a Transfer event with
    /// the _from address set to 0x0 when tokens are created.
    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    /// MUST trigger on any successful call to approve(address _spender, uint256 _value).
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

pragma solidity >=0.4.21 <0.6.0;

contract Migrations {
  address public owner;
  uint public last_completed_migration;

  constructor() public {
    owner = msg.sender;
  }

  modifier restricted() {
    if (msg.sender == owner) _;
  }

  function setCompleted(uint completed) public restricted {
    last_completed_migration = completed;
  }

  function upgrade(address new_address) public restricted {
    Migrations upgraded = Migrations(new_address);
    upgraded.setCompleted(last_completed_migration);
  }
}

pragma solidity ^0.5.0;

import './EIP20.sol';

/// @author robinhood.casino
/// @title Robinhood (RHC) ERC20 token
contract RHC is EIP20 {

  /// @notice reports number of tokens that are promised to vest in a future date
  uint256 public pendingGrants;

  /// @notice raised when tokens are issued for an account
  event Issuance(address indexed _beneficiary, uint256 _amount);

  struct Grant {
    /// number of shares in the grant
    uint256 amount;
    /// a linux timestamp of when shares can be claimed
    uint vestTime;
    /// whether the claim has been cancelled by admins
    bool isCancelled;
    /// whether the grant has been claimed by the user
    bool isClaimed;
  }

  /// @dev token balance of all addresses
  mapping (address => uint256) private _balances;

  /// @dev tracks who can spend how much.
  mapping (address => mapping (address => uint256)) private _allowances;

  /// @dev balance of tokens that are not vested yet
  mapping (address => Grant[]) private _grants;

  // used for access management
  address private _owner;
  mapping (address => bool) private _admins;

  constructor(address admin) public {
    _owner = admin;
  }

  /// @notice name of the Robinhood token
  function name() public pure returns (string memory) {
    return "Robinhood";
  }

  /// @notice symbol of the Robinhood token
  function symbol() public pure returns (string memory) {
    return "RHC";
  }

  /// @notice RHC does not allow breaking up of tokens into fractions.
  function decimals() public pure returns (uint8) {
    return 0;
  }

  modifier onlyAdmins() {
    require(msg.sender == _owner || _admins[msg.sender] == true, "only admins can invoke this function");
    _;
  }

  /// @dev registers a new admin
  function addAdmin(address admin) public onlyAdmins() {
    _admins[admin] = true;
  }

  /// @dev removes an existing admin
  function removeAdmin(address admin) public onlyAdmins() {
    require(admin != _owner, "owner can't be removed");
    delete _admins[admin];
  }

  /// @dev Gets the balance of the specified address.
  /// @param owner The address to query the balance of.
  /// @return A uint256 representing the amount owned by the passed address.
  function balanceOf(address owner) public view returns (uint256) {
      return _balances[owner];
  }

  /// @dev Function to check the amount of tokens that an owner allowed to a spender.
  /// @param owner address The address which owns the funds.
  /// @param spender address The address which will spend the funds.
  /// @return A uint256 specifying the amount of tokens still available for the spender.
  function allowance(address owner, address spender) public view returns (uint256) {
      return _allowances[owner][spender];
  }

  /// @dev Transfer token to a specified address.
  /// @param to The address to transfer to.
  /// @param value The amount to be transferred.
  function transfer(address to, uint256 value) public returns (bool success) {
    require(to != address(0), "Can't transfer tokens to address 0");
    require(balanceOf(msg.sender) >= value, "You don't have sufficient balance to move tokens");

    _move(msg.sender, to, value);

    return true;
  }

  /// @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
  /// Beware that changing an allowance with this method brings the risk that someone may use both the old
  /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
  /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
  /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
  /// @param spender The address which will spend the funds.
  /// @param value The amount of tokens to be spent.
  function approve(address spender, uint256 value) public returns (bool success) {
    require(spender != address(0), "Can't set allowance for address 0");
    require(spender != msg.sender, "Use transfer to move your own funds");

    _allowances[msg.sender][spender] = value;
    emit Approval(msg.sender, spender, value);
    return true;
  }

  /// @dev Transfer tokens from one address to another.
  /// @param from address The address which you want to send tokens from
  /// @param to address The address which you want to transfer to
  /// @param value uint256 the amount of tokens to be transferred
  function transferFrom(address from, address to, uint256 value) public returns (bool) {
    require(to != address(0), "Can't transfer funds to address 0");

    // Validate that the sender is allowed to move funds on behalf of the owner
    require(allowance(from, msg.sender) >= value, "You're not authorized to transfer funds from this account");
    require(balanceOf(from) >= value, "Owner of funds does not have sufficient balance");

    // Decrease allowance
    _allowances[from][msg.sender] -= value;

    // Move actual token balances
    _move(from, to, value);

    return true;
  }

  /// @notice cancels all grants pending for a given beneficiary. If you want to cancel a single
  /// vest, cancel all pending grants, and reinstate the ones you plan to keep
  function cancelGrants(address beneficiary) public onlyAdmins() {
    Grant[] storage userGrants = _grants[beneficiary];
    for (uint i = 0; i < userGrants.length; i++) {
      Grant storage grant = userGrants[i];
      if (!grant.isCancelled && !grant.isClaimed) {
        grant.isCancelled = true;

        // remove from pending grants
        pendingGrants -= grant.amount;
      }
    }
  }

  /// @notice Converts a vest schedule into actual shares. Must be called by the beneficiary
  // to convert their vests into actual shares
  function claimGrant() public {
    Grant[] storage userGrants = _grants[msg.sender];
    for (uint i = 0; i < userGrants.length; i++) {
      Grant storage grant = userGrants[i];
      if (!grant.isCancelled && !grant.isClaimed && now >= grant.vestTime) {
        grant.isClaimed = true;

        // remove from pending grants
        pendingGrants -= grant.amount;

        // issue tokens to the user
        _issue(msg.sender, grant.amount);
      }
    }
  }

  /// @notice returns information about a grant that user has. Returns a tuple indicating
  /// the amount of the grant, when it will vest, whether it's been cancelled, and whether it's been claimed
  /// already.
  /// @param grantIndex a 0-based index of user's grant to retrieve
  function getGrant(address beneficiary, uint grantIndex) public view returns (uint, uint, bool, bool) {
    Grant[] storage grants = _grants[beneficiary];
    if (grantIndex < grants.length) {
      Grant storage grant = grants[grantIndex];
      return (grant.amount, grant.vestTime, grant.isCancelled, grant.isClaimed);
    } else {
      revert("grantIndex must be smaller than length of grants");
    }
  }

  /// @notice returns number of grants a user has
  function getGrantCount(address beneficiary) public view returns (uint) {
    return _grants[beneficiary].length;
  }

  /// @dev Internal function that increases the token supply by issuing new ones
  /// and assigning them to an owner.
  /// @param account The account that will receive the created tokens.
  /// @param amount The amount that will be created.
  function issue(address account, uint256 amount) public onlyAdmins() {
    require(account != address(0), "can't mint to address 0");
    require(amount > 0, "must issue a positive amount of tokens");
    _issue(account, amount);
  }

  /// @dev Internal function that grants shares to a beneficiary in a future date.
  /// @param vestTime milliseconds since epoch at which time shares can be claimed
  function grant(address account, uint256 amount, uint vestTime) public onlyAdmins() {
    require(account != address(0), "grant to the zero address is not allowed");
    require(vestTime > now, "vest schedule must be in the future");

    pendingGrants += amount;
    _grants[account].push(Grant(amount, vestTime, false, false));
  }

  /// @dev Internal helper to move balances around between two accounts.
  function _move(address from, address to, uint256 value) private {
    _balances[from] -= value;
    _balances[to] += value;
    emit Transfer(from, to, value);
  }

  /// @dev issues/mints new tokens for the specified account
  function _issue(address account, uint256 amount) private {
    totalSupply += amount;
    _balances[account] += amount;
    emit Issuance(account, amount);
  }
}

pragma solidity ^0.5.0;

import "./RHC.sol";

/// @author robinhood.casino
/// @title A voting contract that allows shareholders to vote on various business decisions, for example
/// on how much to raise the fee the card dealers are charged.
/// @notice The voting choices are tracked as integers to keep the gas cost of the vote low for participants.
/// the contract only knows how many choices there are but doesn't understand the choices themselves. Robinhood
/// admins will explain the meaning of choices to shareholders when they instantiate a vote. For example,
/// choice 0 means to raise the fee to 10%, and choice 1 means to raise the fee to 20%.
contract Vote {
  /// reference to the token for determining voting rights
  RHC private token;

  /// @dev number of choices available for voters to choose from
  uint public numChoices;

  /// @notice number of votes cast by shareholders
  uint256 public voteCount;

  /// @dev tracks how many votes each choice has received
  mapping (uint => uint256) private votes;

  /// @dev tracks who has voted so far to prevent double voting
  mapping (address => bool) private voters;

  /// @notice this event is raised when a shareholder casts a vote. The weight parameter is determined
  /// based on share ownership and indicates with what weight the vote is counted
  event VoteCast(address shareholder, uint choice, uint256 weight);

  constructor(RHC rhc, uint choices) public {
    require(address(rhc) != address(0), "must provide a valid RHC token address");
    require(choices > 0, "must have at least one choice to vote on");
    token = rhc;
    numChoices = choices;
  }

  /// @notice casts a vote for a given choice
  function cast(uint choice) public {
    require(choice < numChoices, "invalid choice to vote on");
    require(voters[msg.sender] == false, "you've already cast your vote, can't vote twice");

    address voter = msg.sender;
    uint256 weight = token.balanceOf(voter);

    require(weight > 0, "you don't own any tokens and therefore can't vote");
    require(weight > 1199, "you need to own at least 1200 shares to vote");

    // track the fact that vote has been cast
    voters[voter] = true;
    voteCount++;
    votes[choice] += weight;

    emit VoteCast(voter, choice, weight);
  }

  function getVoteCount(uint choice) public view returns (uint256) {
    require(choice < numChoices, "must ask for a valid vote choice");
    return votes[choice];
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"isSaleOpen","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"weiRaised","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokensSold","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"money","type":"uint256"}],"name":"calculateTokenCount","outputs":[{"name":"count","type":"uint256"},{"name":"change","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"targetWallet","type":"address"},{"name":"roundPrices","type":"uint256[]"},{"name":"roundCapacities","type":"uint256[]"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"amountSent","type":"uint256"},{"indexed":false,"name":"amountReturned","type":"uint256"},{"indexed":false,"name":"tokensSold","type":"uint256"},{"indexed":false,"name":"buyer","type":"address"}],"name":"Sale","type":"event"},{"anonymous":false,"inputs":[],"name":"SaleCompleted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"oldTokenPrice","type":"uint256"},{"indexed":false,"name":"newTokenPrice","type":"uint256"}],"name":"RoundChanged","type":"event"}]

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

00000000000000000000000030f02e798bafef5a343c531c3a792a2ebf2ff95e000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000344078282c50000000000000000000000000000000000000000000000000000037bc3bbb25e000000000000000000000000000000000000000000000000000003b37ff8970fc00000000000000000000000000000000000000000000000000003eb3c357bc18000000000000000000000000000000000000000000000000000045ab4ab83d740000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000f4240

-----Decoded View---------------
Arg [0] : targetWallet (address): 0x30F02e798BAfeF5a343c531C3A792a2eBf2fF95E
Arg [1] : roundPrices (uint256[]): 919223975200000,980505528000000,1041787143000000,1103068758000000,1225631925000000
Arg [2] : roundCapacities (uint256[]): 1000000,1000000,1000000,1000000,1000000

-----Encoded View---------------
15 Constructor Arguments found :
Arg [0] : 00000000000000000000000030f02e798bafef5a343c531c3a792a2ebf2ff95e
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [4] : 000000000000000000000000000000000000000000000000000344078282c500
Arg [5] : 00000000000000000000000000000000000000000000000000037bc3bbb25e00
Arg [6] : 0000000000000000000000000000000000000000000000000003b37ff8970fc0
Arg [7] : 0000000000000000000000000000000000000000000000000003eb3c357bc180
Arg [8] : 00000000000000000000000000000000000000000000000000045ab4ab83d740
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [10] : 00000000000000000000000000000000000000000000000000000000000f4240
Arg [11] : 00000000000000000000000000000000000000000000000000000000000f4240
Arg [12] : 00000000000000000000000000000000000000000000000000000000000f4240
Arg [13] : 00000000000000000000000000000000000000000000000000000000000f4240
Arg [14] : 00000000000000000000000000000000000000000000000000000000000f4240

46:4912:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2423:9;2462:10;2486;2478:52;;;;;-1:-1:-1;;;;;2478:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2544:19:0;;2536:57;;;;;-1:-1:-1;;;;;2536:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;2607:10;;-1:-1:-1;;;2607:10:0;;;;2599:68;;;;-1:-1:-1;;;;;2599:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2675:15;2692:11;2707:27;2727:6;2707:19;:27::i;:::-;2674:60;;;;2807:10;2821:1;2807:15;2803:72;;;2832:22;;-1:-1:-1;;;;;2832:14:0;;;:22;;;;;2847:6;;2832:22;;;;2847:6;2832:14;:22;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;2832:22:0;2862:7;;;;;;2803:72;3031:6;;:30;;2979:15;;;;3031:6;;;-1:-1:-1;;;;;3031:6:0;;:30;;;;;2979:15;;2958:18;3031:30;2958:18;3031:30;2979:15;3031:6;:30;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;3126:22:0;;-1:-1:-1;;;;;3126:14:0;;;:22;;;;;3141:6;;3126:22;;;;3141:6;3126:14;:22;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;3201:5:0;;:30;;;-1:-1:-1;;;;;3201:30:0;;-1:-1:-1;;;;;3201:30:0;;;;;;;;;;;;;;;:5;;;;;:11;;:30;;;;;:5;;:30;;;;;;;:5;;:30;;;5:2:-1;;;;30:1;27;20:12;5:2;3201:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;3303:9:0;:26;;;;;;-1:-1:-1;;3335:10:0;:24;;;;;;3366;3349:10;3366:12;:24::i;:::-;3402:39;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;3402:39:0;;;;;;;;;;;;;;;;;2375:1071;;;;;;46:4912;1314:22;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1314:22:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;1388:21;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1388:21:0;;;:::i;:::-;;;;;;;;;;;;;;;;1463:22;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1463:22:0;;;:::i;1240:16::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1240:16:0;;;:::i;:::-;;;;-1:-1:-1;;;;;1240:16:0;;;;;;;;;;;;;;3577:870;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3577:870:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3577:870:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;3678:10;;3639;;;;-1:-1:-1;;;3678:10:0;;;;3670:75;;;;-1:-1:-1;;;;;3670:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3804:13;;3783:10;3796:22;;3783:10;;;;3804:13;;;;;3796:22;;;;;;;;;;;;;;;;;;:33;3863:13;;3855:22;;3796:33;;-1:-1:-1;3796:22:0;;3863:13;;;;;3855:22;;;;;;;;;;;;;;;;:35;;;3835:55;;4003:5;3995;:13;3991:81;;;-1:-1:-1;4056:1:0;;-1:-1:-1;4059:5:0;;-1:-1:-1;4048:17:0;;-1:-1:-1;4048:17:0;3991:81;4094:5;4086;:13;;;;;;4078:21;;4122:5;4114;:13;;;;;;4105:22;;4317:12;4309:5;:20;4305:109;;;4366:12;4358:5;:20;4349:5;:30;4339:40;;;;4395:12;4387:20;;4305:109;-1:-1:-1;;3577:870:0;;;;:::o;4519:437::-;4605:13;;4568:26;4597:22;;4568:26;;;;4605:13;;;;;4597:22;;;;;;;;;;;;;;;;;;;4625:25;;;:35;;;;;;;;;4597:22;;-1:-1:-1;4667:285:0;;4732:7;:14;4749:1;4715:13;;;-1:-1:-1;;4732:18:0;;;4715:35;4711:235;;;4762:10;:18;;-1:-1:-1;;4762:18:0;;;4795:15;;;;4775:5;;4795:15;4711:235;;;4835:13;:15;;-1:-1:-1;;4835:15:0;;;;;;;;;;;;;;;4878:23;;-1:-1:-1;4903:22:0;;4865:72;;4878:23;;-1:-1:-1;;4911:13:0;;;;4903:22;;;;;;;;;;;;;;;;;;;;:33;4865:72;;;;;;;;;;;;;;;;;;;4711:235;4519:437;;:::o;1314:22::-;;;-1:-1:-1;;;1314:22:0;;;;;:::o;1388:21::-;;;;:::o;1463:22::-;;;;:::o;1240:16::-;;;-1:-1:-1;;;;;1240:16:0;;:::o

bzzr://d5e8a05bcd09bf3167eb18e99c2656410a79630e9f155863a24e25cae38636bd