Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-11-23
*/

/**
 *Submitted for verification at Etherscan.io on 2019-11-23
*/

pragma solidity ^0.5.13;
pragma experimental ABIEncoderV2;

library SafeMath {

    function mul(uint a, uint b) internal pure returns (uint) {
        uint c = a * b;
        require(a == 0 || c / a == b);
        return c;
    }

    function div(uint a, uint b) internal pure returns (uint) {
        require(b > 0);
        uint c = a / b;
        require(a == b * c + a % b);
        return c;
    }

    function sub(uint a, uint b) internal pure returns (uint) {
        require(b <= a);
        return a - b;
    }

    function add(uint a, uint b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a);
        return c;
    }

    function max64(uint64 a, uint64 b) internal pure returns (uint64) {
        return a >= b ? a : b;
    }

    function min64(uint64 a, uint64 b) internal pure returns (uint64) {
        return a < b ? a : b;
    }

    function max256(uint a, uint b) internal pure returns (uint) {
        return a >= b ? a : b;
    }

    function min256(uint a, uint b) internal pure returns (uint) {
        return a < b ? a : b;
    }
}

interface GeneralERC20 {
	function transfer(address to, uint256 value) external;
	function transferFrom(address from, address to, uint256 value) external;
	function approve(address spender, uint256 value) external;
	function balanceOf(address spender) external view returns (uint);
	function allowance(address owner, address spender) external view returns (uint);
}

library SafeERC20 {
	function checkSuccess()
		private
		pure
		returns (bool)
	{
		uint256 returnValue = 0;

		assembly {
			// check number of bytes returned from last function call
			switch returndatasize

			// no bytes returned: assume success
			case 0x0 {
				returnValue := 1
			}

			// 32 bytes returned: check if non-zero
			case 0x20 {
				// copy 32 bytes into scratch space
				returndatacopy(0x0, 0x0, 0x20)

				// load those bytes into returnValue
				returnValue := mload(0x0)
			}

			// not sure what was returned: don't mark as success
			default { }
		}

		return returnValue != 0;
	}

	function transfer(address token, address to, uint256 amount) internal {
		GeneralERC20(token).transfer(to, amount);
		require(checkSuccess());
	}

	function transferFrom(address token, address from, address to, uint256 amount) internal {
		GeneralERC20(token).transferFrom(from, to, amount);
		require(checkSuccess());
	}

	function approve(address token, address spender, uint256 amount) internal {
		GeneralERC20(token).approve(spender, amount);
		require(checkSuccess());
	}
}

library SignatureValidator {
	enum SignatureMode {
		NO_SIG,
		EIP712,
		GETH,
		TREZOR,
		ADEX
	}

	function recoverAddr(bytes32 hash, bytes32[3] memory signature) internal pure returns (address) {
		SignatureMode mode = SignatureMode(uint8(signature[0][0]));

		if (mode == SignatureMode.NO_SIG) {
			return address(0x0);
		}

		uint8 v = uint8(signature[0][1]);

		if (mode == SignatureMode.GETH) {
			hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
		} else if (mode == SignatureMode.TREZOR) {
			hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n\x20", hash));
		} else if (mode == SignatureMode.ADEX) {
			hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n108By signing this message, you acknowledge signing an AdEx bid with the hash:\n", hash));
		}

		return ecrecover(hash, v, signature[1], signature[2]);
	}

	/// @dev Validates that a hash was signed by a specified signer.
	/// @param hash Hash which was signed.
	/// @param signer Address of the signer.
	/// @param signature ECDSA signature along with the mode [{mode}{v}, {r}, {s}]
	/// @return Returns whether signature is from a specified user.
	function isValidSignature(bytes32 hash, address signer, bytes32[3] memory signature) internal pure returns (bool) {
		return recoverAddr(hash, signature) == signer;
	}
}


library ChannelLibrary {
	uint constant MAX_VALIDITY = 365 days;

	// Both numbers are inclusive
	uint constant MIN_VALIDATOR_COUNT = 2;
	// This is an arbitrary number, but we impose this limit to restrict on-chain load; also to ensure the *3 operation is safe
	uint constant MAX_VALIDATOR_COUNT = 25;

	enum State {
		Unknown,
		Active,
		Expired
	}

	struct Channel {
		address creator;

		address tokenAddr;
		uint tokenAmount;

		uint validUntil;

		address[] validators;

		// finally, arbitrary bytes32 that allows to... @TODO document that this acts as a nonce
		bytes32 spec;
	}

	function hash(Channel memory channel)
		internal
		view
		returns (bytes32)
	{
		// In this version of solidity, we can no longer keccak256() directly
		return keccak256(abi.encode(
			address(this),
			channel.creator,
			channel.tokenAddr,
			channel.tokenAmount,
			channel.validUntil,
			channel.validators,
			channel.spec
		));
	}

	function isValid(Channel memory channel, uint currentTime)
		internal
		pure
		returns (bool)
	{
		// NOTE: validators[] can be sybil'd by passing the same addr a few times
		// this does not matter since you can sybil validators[] anyway, and that is mitigated off-chain
		if (channel.validators.length < MIN_VALIDATOR_COUNT) {
			return false;
		}
		if (channel.validators.length > MAX_VALIDATOR_COUNT) {
			return false;
		}
		if (channel.validUntil < currentTime) {
			return false;
		}
		if (channel.validUntil > (currentTime + MAX_VALIDITY)) {
			return false;
		}

		return true;
	}

	function isSignedBySupermajority(Channel memory channel, bytes32 toSign, bytes32[3][] memory signatures) 
		internal
		pure
		returns (bool)
	{
		// NOTE: each element of signatures[] must signed by the elem with the same index in validators[]
		// In case someone didn't sign, pass SignatureMode.NO_SIG
		if (signatures.length != channel.validators.length) {
			return false;
		}

		uint signs = 0;
		uint sigLen = signatures.length;
		for (uint i=0; i<sigLen; i++) {
			// NOTE: if a validator has not signed, you can just use SignatureMode.NO_SIG
			if (SignatureValidator.isValidSignature(toSign, channel.validators[i], signatures[i])) {
				signs++;
			} else if (i == 0) {
				// The 0th signature is always from the leading validator, so it doesn't make sense for other sigs to exist if this one does not
				return false;
			}
		}
		return signs*3 >= channel.validators.length*2;
	}
}

library MerkleProof {
	function isContained(bytes32 valueHash, bytes32[] memory proof, bytes32 root) internal pure returns (bool) {
		bytes32 cursor = valueHash;

		uint256 proofLen = proof.length;
		for (uint256 i = 0; i < proofLen; i++) {
			if (cursor < proof[i]) {
				cursor = keccak256(abi.encodePacked(cursor, proof[i]));
			} else {
				cursor = keccak256(abi.encodePacked(proof[i], cursor));
			}
		}

		return cursor == root;
	}
}


// AUDIT: Things we should look for
// 1) every time we check the state, the function should either revert or change the state
// 2) state transition: channelOpen locks up tokens, then all of the tokens can be withdrawn on channelExpiredWithdraw, except how many were withdrawn using channelWithdraw
// 3) external calls (everything using SafeERC20) should be at the end
// 4) channel can always be 100% drained with Withdraw/ExpiredWithdraw

contract AdExCore {
	using SafeMath for uint;
	using ChannelLibrary for ChannelLibrary.Channel;

 	// channelId => channelState
	mapping (bytes32 => ChannelLibrary.State) public states;
	
	// withdrawn per channel (channelId => uint)
	mapping (bytes32 => uint) public withdrawn;
	// withdrawn per channel user (channelId => (account => uint))
	mapping (bytes32 => mapping (address => uint)) public withdrawnPerUser;

	// Events
	event LogChannelOpen(bytes32 indexed channelId);
	event LogChannelWithdrawExpired(bytes32 indexed channelId, uint amount);
	event LogChannelWithdraw(bytes32 indexed channelId, uint amount);

	// All functions are public
	function channelOpen(ChannelLibrary.Channel memory channel)
		public
	{
		bytes32 channelId = channel.hash();
		require(states[channelId] == ChannelLibrary.State.Unknown, "INVALID_STATE");
		require(msg.sender == channel.creator, "INVALID_CREATOR");
		require(channel.isValid(now), "INVALID_CHANNEL");
		
		states[channelId] = ChannelLibrary.State.Active;

		SafeERC20.transferFrom(channel.tokenAddr, msg.sender, address(this), channel.tokenAmount);

		emit LogChannelOpen(channelId);
	}

	function channelWithdrawExpired(ChannelLibrary.Channel memory channel)
		public
	{
		bytes32 channelId = channel.hash();
		require(states[channelId] == ChannelLibrary.State.Active, "INVALID_STATE");
		require(now > channel.validUntil, "NOT_EXPIRED");
		require(msg.sender == channel.creator, "INVALID_CREATOR");
		
		uint toWithdraw = channel.tokenAmount.sub(withdrawn[channelId]);

		// NOTE: we will not update withdrawn, since a WithdrawExpired does not count towards normal withdrawals
		states[channelId] = ChannelLibrary.State.Expired;
		
		SafeERC20.transfer(channel.tokenAddr, msg.sender, toWithdraw);

		emit LogChannelWithdrawExpired(channelId, toWithdraw);
	}

	function channelWithdraw(ChannelLibrary.Channel memory channel, bytes32 stateRoot, bytes32[3][] memory signatures, bytes32[] memory proof, uint amountInTree)
		public
	{
		bytes32 channelId = channel.hash();
		require(states[channelId] == ChannelLibrary.State.Active, "INVALID_STATE");
		require(now <= channel.validUntil, "EXPIRED");

		bytes32 hashToSign = keccak256(abi.encode(channelId, stateRoot));
		require(channel.isSignedBySupermajority(hashToSign, signatures), "NOT_SIGNED_BY_VALIDATORS");

		bytes32 balanceLeaf = keccak256(abi.encode(msg.sender, amountInTree));
		require(MerkleProof.isContained(balanceLeaf, proof, stateRoot), "BALANCELEAF_NOT_FOUND");

		// The user can withdraw their constantly increasing balance at any time (essentially prevent users from double spending)
		uint toWithdraw = amountInTree.sub(withdrawnPerUser[channelId][msg.sender]);
		withdrawnPerUser[channelId][msg.sender] = amountInTree;

		// Ensure that it's not possible to withdraw more than the channel deposit (e.g. malicious validators sign such a state)
		withdrawn[channelId] = withdrawn[channelId].add(toWithdraw);
		require(withdrawn[channelId] <= channel.tokenAmount, "WITHDRAWING_MORE_THAN_CHANNEL");

		SafeERC20.transfer(channel.tokenAddr, msg.sender, toWithdraw);

		emit LogChannelWithdraw(channelId, toWithdraw);
	}
}

contract Identity {
	using SafeMath for uint;

	// Storage
	// WARNING: be careful when modifying this
	// privileges and routineAuthorizations must always be 0th and 1th thing in storage,
	// because of the proxies we generate that delegatecall into this contract (which assume storage slot 0 and 1)
	mapping (address => uint8) public privileges;
	// Routine authorizations
	mapping (bytes32 => bool) public routineAuthorizations;
	// The next allowed nonce
	uint public nonce = 0;
	// Routine operations are authorized at once for a period, fee is paid once
	mapping (bytes32 => uint256) public routinePaidFees;

	// Constants
	bytes4 private constant CHANNEL_WITHDRAW_SELECTOR = bytes4(keccak256('channelWithdraw((address,address,uint256,uint256,address[],bytes32),bytes32,bytes32[3][],bytes32[],uint256)'));
	bytes4 private constant CHANNEL_WITHDRAW_EXPIRED_SELECTOR = bytes4(keccak256('channelWithdrawExpired((address,address,uint256,uint256,address[],bytes32))'));

	enum PrivilegeLevel {
		None,
		Routines,
		Transactions
	}
	enum RoutineOp {
		ChannelWithdraw,
		ChannelWithdrawExpired
	}

	// Events
	event LogPrivilegeChanged(address indexed addr, uint8 privLevel);
	event LogRoutineAuth(bytes32 hash, bool authorized);

	// Transaction structure
	// Those can be executed by keys with >= PrivilegeLevel.Transactions
	// Even though the contract cannot receive ETH, we are able to send ETH (.value), cause ETH might've been sent to the contract address before it's deployed
	struct Transaction {
		// replay protection
		address identityContract;
		uint nonce;
		// tx fee, in tokens
		address feeTokenAddr;
		uint feeAmount;
		// all the regular txn data
		address to;
		uint value;
		bytes data;
	}

	// RoutineAuthorizations allow the user to authorize (via keys >= PrivilegeLevel.Routines) a relayer to do any number of routines
	// those routines are safe: e.g. sweeping channels (withdrawing off-chain balances to the identity)
	// while the fee will be paid only ONCE per auth per period (1 week), the authorization can be used until validUntil
	// while the routines are safe, there is some level of implied trust as the relayer may run executeRoutines without any routines to claim the fee
	struct RoutineAuthorization {
		address relayer;
		address outpace;
		uint validUntil;
		address feeTokenAddr;
		uint weeklyFeeAmount;
	}
	struct RoutineOperation {
		RoutineOp mode;
		bytes data;
	}

	constructor(address[] memory addrs, uint8[] memory privLevels)
		public
	{
		uint len = privLevels.length;
		for (uint i=0; i<len; i++) {
			privileges[addrs[i]] = privLevels[i];
			emit LogPrivilegeChanged(addrs[i], privLevels[i]);
		}
	}

	function setAddrPrivilege(address addr, uint8 privLevel)
		external
	{
		require(msg.sender == address(this), 'ONLY_IDENTITY_CAN_CALL');
		privileges[addr] = privLevel;
		emit LogPrivilegeChanged(addr, privLevel);
	}

	function setRoutineAuth(bytes32 hash, bool authorized)
		external
	{
		require(msg.sender == address(this), 'ONLY_IDENTITY_CAN_CALL');
		routineAuthorizations[hash] = authorized;
		emit LogRoutineAuth(hash, authorized);
	}

	function channelOpen(address coreAddr, ChannelLibrary.Channel memory channel)
		public
	{
		require(msg.sender == address(this), 'ONLY_IDENTITY_CAN_CALL');
		if (GeneralERC20(channel.tokenAddr).allowance(address(this), coreAddr) > 0) {
			SafeERC20.approve(channel.tokenAddr, coreAddr, 0);
		}
		SafeERC20.approve(channel.tokenAddr, coreAddr, channel.tokenAmount);
		AdExCore(coreAddr).channelOpen(channel);
	}

	function execute(Transaction[] memory txns, bytes32[3][] memory signatures)
		public
	{
		require(txns.length > 0, 'MUST_PASS_TX');
		address feeTokenAddr = txns[0].feeTokenAddr;
		uint feeAmount = 0;
		uint len = txns.length;
		for (uint i=0; i<len; i++) {
			Transaction memory txn = txns[i];
			require(txn.identityContract == address(this), 'TRANSACTION_NOT_FOR_CONTRACT');
			require(txn.feeTokenAddr == feeTokenAddr, 'EXECUTE_NEEDS_SINGLE_TOKEN');
			require(txn.nonce == nonce, 'WRONG_NONCE');

			// If we use the naive abi.encode(txn) and have a field of type `bytes`,
			// there is a discrepancy between ethereumjs-abi and solidity
			// if we enter every field individually, in order, there is no discrepancy
			//bytes32 hash = keccak256(abi.encode(txn));
			bytes32 hash = keccak256(abi.encode(txn.identityContract, txn.nonce, txn.feeTokenAddr, txn.feeAmount, txn.to, txn.value, txn.data));
			address signer = SignatureValidator.recoverAddr(hash, signatures[i]);

			require(privileges[signer] >= uint8(PrivilegeLevel.Transactions), 'INSUFFICIENT_PRIVILEGE_TRANSACTION');

			nonce = nonce.add(1);
			feeAmount = feeAmount.add(txn.feeAmount);

			executeCall(txn.to, txn.value, txn.data);
			// The actual anti-bricking mechanism - do not allow a signer to drop his own priviledges
			require(privileges[signer] >= uint8(PrivilegeLevel.Transactions), 'PRIVILEGE_NOT_DOWNGRADED');
		}
		if (feeAmount > 0) {
			SafeERC20.transfer(feeTokenAddr, msg.sender, feeAmount);
		}
	}

	function executeBySender(Transaction[] memory txns)
		public
	{
		require(privileges[msg.sender] >= uint8(PrivilegeLevel.Transactions), 'INSUFFICIENT_PRIVILEGE_SENDER');
		uint len = txns.length;
		for (uint i=0; i<len; i++) {
			Transaction memory txn = txns[i];
			require(txn.nonce == nonce, 'WRONG_NONCE');

			nonce = nonce.add(1);

			executeCall(txn.to, txn.value, txn.data);
		}
		// The actual anti-bricking mechanism - do not allow the sender to drop his own priviledges
		require(privileges[msg.sender] >= uint8(PrivilegeLevel.Transactions), 'PRIVILEGE_NOT_DOWNGRADED');
	}

	function executeRoutines(RoutineAuthorization memory auth, RoutineOperation[] memory operations)
		public
	{
		require(auth.validUntil >= now, 'AUTHORIZATION_EXPIRED');
		bytes32 hash = keccak256(abi.encode(auth));
		require(routineAuthorizations[hash], 'NO_AUTHORIZATION');
		uint len = operations.length;
		for (uint i=0; i<len; i++) {
			RoutineOperation memory op = operations[i];
			if (op.mode == RoutineOp.ChannelWithdraw) {
				// Channel: Withdraw
				executeCall(auth.outpace, 0, abi.encodePacked(CHANNEL_WITHDRAW_SELECTOR, op.data));
			} else if (op.mode == RoutineOp.ChannelWithdrawExpired) {
				// Channel: Withdraw Expired
				executeCall(auth.outpace, 0, abi.encodePacked(CHANNEL_WITHDRAW_EXPIRED_SELECTOR, op.data));
			} else {
				revert('INVALID_MODE');
			}
		}
		if (auth.weeklyFeeAmount > 0 && (now - routinePaidFees[hash]) >= 7 days) {
			routinePaidFees[hash] = now;
			SafeERC20.transfer(auth.feeTokenAddr, auth.relayer, auth.weeklyFeeAmount);
		}
	}

	// we shouldn't use address.call(), cause: https://github.com/ethereum/solidity/issues/2884
	// copied from https://github.com/uport-project/uport-identity/blob/develop/contracts/Proxy.sol
	// there's also
	// https://github.com/gnosis/MultiSigWallet/commit/e1b25e8632ca28e9e9e09c81bd20bf33fdb405ce
	// https://github.com/austintgriffith/bouncer-proxy/blob/master/BouncerProxy/BouncerProxy.sol
	// https://github.com/gnosis/safe-contracts/blob/7e2eeb3328bb2ae85c36bc11ea6afc14baeb663c/contracts/base/Executor.sol
	function executeCall(address to, uint256 value, bytes memory data)
		internal
	{
		assembly {
			let result := call(gas, to, value, add(data, 0x20), mload(data), 0, 0)

			switch result case 0 {
				let size := returndatasize
				let ptr := mload(0x40)
				returndatacopy(ptr, 0, size)
				revert(ptr, size)
			}
			default {}
		}
	}
}

contract IdentityFactory {
	event LogDeployed(address addr, uint256 salt);

	address public creator;
	constructor() public {
		creator = msg.sender;
	}

	function deploy(bytes memory code, uint256 salt) public {
		deploySafe(code, salt);
	}

	// When the relayer needs to act upon an /execute call, it'll either call execute on the Identity directly
	// if it's already deployed, or call `deployAndExecute` if the account is still counterfactual
	function deployAndExecute(
		bytes memory code, uint256 salt,
		Identity.Transaction[] memory txns, bytes32[3][] memory signatures
	) public {
		address addr = deploySafe(code, salt);
		Identity(addr).execute(txns, signatures);
	}

	// When the relayer needs to do routines, it'll either call executeRoutines on the Identity directly
	// if it's already deployed, or call `deployAndRoutines` if the account is still counterfactual
	function deployAndRoutines(
		bytes memory code, uint256 salt,
		Identity.RoutineAuthorization memory auth, Identity.RoutineOperation[] memory operations
	) public {
		address addr = deploySafe(code, salt);
		Identity(addr).executeRoutines(auth, operations);
	}

	// Withdraw the earnings from various fees (deploy fees and execute fees earned cause of `deployAndExecute`)
	function withdraw(address tokenAddr, address to, uint256 tokenAmount) public {
		require(msg.sender == creator, 'ONLY_CREATOR');
		SafeERC20.transfer(tokenAddr, to, tokenAmount);
	}

	// This is done to mitigate possible frontruns where, for example, deploying the same code/salt via deploy()
	// would make a pending deployAndExecute fail
	// The way we mitigate that is by checking if the contract is already deployed and if so, we continue execution
	function deploySafe(bytes memory code, uint256 salt) internal returns (address) {
		address expectedAddr = address(uint160(uint256(
			keccak256(abi.encodePacked(byte(0xff), address(this), salt, keccak256(code)))
		)));
		uint size;
		assembly { size := extcodesize(expectedAddr) }
		// If there is code at that address, we can assume it's the one we were about to deploy,
		// because of how CREATE2 and keccak256 works
		if (size == 0) {
			address addr;
			assembly { addr := create2(0, add(code, 0x20), mload(code), salt) }
			require(addr != address(0), 'FAILED_DEPLOYING');
			require(addr == expectedAddr, 'FAILED_MATCH');
			emit LogDeployed(addr, salt);
		}
		return expectedAddr;
	}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"uint256","name":"salt","type":"uint256"}],"name":"LogDeployed","type":"event"},{"constant":true,"inputs":[],"name":"creator","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"code","type":"bytes"},{"internalType":"uint256","name":"salt","type":"uint256"}],"name":"deploy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"code","type":"bytes"},{"internalType":"uint256","name":"salt","type":"uint256"},{"components":[{"internalType":"address","name":"identityContract","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"address","name":"feeTokenAddr","type":"address"},{"internalType":"uint256","name":"feeAmount","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Identity.Transaction[]","name":"txns","type":"tuple[]"},{"internalType":"bytes32[3][]","name":"signatures","type":"bytes32[3][]"}],"name":"deployAndExecute","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"code","type":"bytes"},{"internalType":"uint256","name":"salt","type":"uint256"},{"components":[{"internalType":"address","name":"relayer","type":"address"},{"internalType":"address","name":"outpace","type":"address"},{"internalType":"uint256","name":"validUntil","type":"uint256"},{"internalType":"address","name":"feeTokenAddr","type":"address"},{"internalType":"uint256","name":"weeklyFeeAmount","type":"uint256"}],"internalType":"struct Identity.RoutineAuthorization","name":"auth","type":"tuple"},{"components":[{"internalType":"enum Identity.RoutineOp","name":"mode","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Identity.RoutineOperation[]","name":"operations","type":"tuple[]"}],"name":"deployAndRoutines","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tokenAddr","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000942f9ce5d9a33a82f88d233aeb3292e680230348
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000942f9ce5d9a33a82f88d233aeb3292e680230348

18368:2459:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18368:2459:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18448:22;;;:::i;:::-;;;;;;;;;;;;;;;;19271:267;;;;;;;;;;;;;;;;:::i;:::-;;18829:236;;;;;;;;;;;;;;;;:::i;:::-;;18530:88;;;;;;;;;;;;;;;;:::i;:::-;;19654:184;;;;;;;;;;;;;;;;:::i;:::-;;18448:22;;;;;;;;;;;;;:::o;19271:267::-;19443:12;19458:22;19469:4;19475;19458:10;:22::i;:::-;19443:37;;19494:4;19485:30;;;19516:4;19522:10;19485:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19485:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19485:48:0;;;;19271:267;;;;;:::o;18829:236::-;18978:12;18993:22;19004:4;19010;18993:10;:22::i;:::-;18978:37;;19029:4;19020:22;;;19043:4;19049:10;19020:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19020:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19020:40:0;;;;18829:236;;;;;:::o;18530:88::-;18591:22;18602:4;18608;18591:10;:22::i;:::-;;18530:88;;:::o;19654:184::-;19758:7;;;;;;;;;;;19744:21;;:10;:21;;;19736:46;;;;;;;;;;;;;;;;;;;;;;19787;19806:9;19817:2;19821:11;19787:18;:46::i;:::-;19654:184;;;:::o;20116:708::-;20187:7;20201:20;20285:4;20280:10;;20300:4;20307;20323;20313:15;;;;;;20263:66;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;20263:66:0;;;20253:77;;;;;;20240:95;;20201:136;;20342:9;20387:12;20375:25;20367:33;;20559:1;20551:4;:9;20547:249;;;20568:12;20646:4;20639;20633:11;20626:4;20620;20616:15;20613:1;20605:46;20597:54;;20682:1;20666:18;;:4;:18;;;;20658:47;;;;;;;;;;;;;;;;;;;;;;20727:12;20719:20;;:4;:20;;;20711:45;;;;;;;;;;;;;;;;;;;;;;20767:23;20779:4;20785;20767:23;;;;;;;;;;;;;;;;20547:249;;20807:12;20800:19;;;;20116:708;;;;:::o;2227:148::-;2315:5;2302:28;;;2331:2;2335:6;2302:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2302:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;2302:40:0;;;;2355:14;:12;:14::i;:::-;2347:23;;;;;;2227:148;;;:::o;1606:616::-;1661:4;1674:19;1696:1;1674:23;;1788:14;1855:3;1850:38;;;;1944:4;1939:169;;;;1781:402;;1850:38;1881:1;1866:16;;1850:38;;1939:169;2022:4;2017:3;2012;1997:30;2098:3;2092:10;2077:25;;1781:402;;2216:1;2201:11;:16;;2194:23;;;1606:616;:::o;5:130:-1:-;;85:6;72:20;63:29;;97:33;124:5;97:33;;;57:78;;;;;163:764;;299:3;292:4;284:6;280:17;276:27;266:2;;317:1;314;307:12;266:2;354:6;341:20;376:99;391:83;467:6;391:83;;;376:99;;;367:108;;492:5;517:6;510:5;503:21;547:4;539:6;535:17;525:27;;569:4;564:3;560:14;553:21;;622:6;669:3;661:4;653:6;649:17;644:3;640:27;637:36;634:2;;;686:1;683;676:12;634:2;711:1;696:225;721:6;718:1;715:13;696:225;;;779:3;801:56;853:3;841:10;801:56;;;796:3;789:69;881:4;876:3;872:14;865:21;;909:4;904:3;900:14;893:21;;753:168;743:1;740;736:9;731:14;;696:225;;;700:14;259:668;;;;;;;;954:607;;1065:3;1058:4;1050:6;1046:17;1042:27;1032:2;;1083:1;1080;1073:12;1032:2;1107:3;1125:74;1140:58;1191:6;1140:58;;;1125:74;;;1116:83;;1216:5;1275:6;1322:3;1314:4;1306:6;1302:17;1297:3;1293:27;1290:36;1287:2;;;1339:1;1336;1329:12;1287:2;1364:1;1349:206;1374:6;1371:1;1368:13;1349:206;;;1432:3;1454:37;1487:3;1475:10;1454:37;;;1449:3;1442:50;1515:4;1510:3;1506:14;1499:21;;1543:4;1538:3;1534:14;1527:21;;1406:149;1396:1;1393;1389:9;1384:14;;1349:206;;;1353:14;1025:536;;;;;;;;1612:768;;1759:3;1752:4;1744:6;1740:17;1736:27;1726:2;;1777:1;1774;1767:12;1726:2;1814:6;1801:20;1836:110;1851:94;1938:6;1851:94;;;1836:110;;;1827:119;;1963:5;1988:6;1981:5;1974:21;2018:4;2010:6;2006:17;1996:27;;2040:4;2035:3;2031:14;2024:21;;2093:6;2126:1;2111:263;2136:6;2133:1;2130:13;2111:263;;;2219:3;2206:17;2198:6;2194:30;2243:67;2306:3;2294:10;2243:67;;;2238:3;2231:80;2334:4;2329:3;2325:14;2318:21;;2362:4;2357:3;2353:14;2346:21;;2168:206;2158:1;2155;2151:9;2146:14;;2111:263;;;2115:14;1719:661;;;;;;;;2426:753;;2568:3;2561:4;2553:6;2549:17;2545:27;2535:2;;2586:1;2583;2576:12;2535:2;2623:6;2610:20;2645:105;2660:89;2742:6;2660:89;;;2645:105;;;2636:114;;2767:5;2792:6;2785:5;2778:21;2822:4;2814:6;2810:17;2800:27;;2844:4;2839:3;2835:14;2828:21;;2897:6;2930:1;2915:258;2940:6;2937:1;2934:13;2915:258;;;3023:3;3010:17;3002:6;2998:30;3047:62;3105:3;3093:10;3047:62;;;3042:3;3035:75;3133:4;3128:3;3124:14;3117:21;;3161:4;3156:3;3152:14;3145:21;;2972:201;2962:1;2959;2955:9;2950:14;;2915:258;;;2919:14;2528:651;;;;;;;;3187:130;;3267:6;3254:20;3245:29;;3279:33;3306:5;3279:33;;;3239:78;;;;;3325:432;;3422:3;3415:4;3407:6;3403:17;3399:27;3389:2;;3440:1;3437;3430:12;3389:2;3477:6;3464:20;3499:60;3514:44;3551:6;3514:44;;;3499:60;;;3490:69;;3579:6;3572:5;3565:21;3615:4;3607:6;3603:17;3648:4;3641:5;3637:16;3683:3;3674:6;3669:3;3665:16;3662:25;3659:2;;;3700:1;3697;3690:12;3659:2;3710:41;3744:6;3739:3;3734;3710:41;;;3382:375;;;;;;;;3766:440;;3867:3;3860:4;3852:6;3848:17;3844:27;3834:2;;3885:1;3882;3875:12;3834:2;3922:6;3909:20;3944:64;3959:48;4000:6;3959:48;;;3944:64;;;3935:73;;4028:6;4021:5;4014:21;4064:4;4056:6;4052:17;4097:4;4090:5;4086:16;4132:3;4123:6;4118:3;4114:16;4111:25;4108:2;;;4149:1;4146;4139:12;4108:2;4159:41;4193:6;4188:3;4183;4159:41;;;3827:379;;;;;;;;4214:158;;4308:6;4295:20;4286:29;;4320:47;4361:5;4320:47;;;4280:92;;;;;4422:943;;4549:4;4537:9;4532:3;4528:19;4524:30;4521:2;;;4567:1;4564;4557:12;4521:2;4585:20;4600:4;4585:20;;;4576:29;;4658:1;4689:49;4734:3;4725:6;4714:9;4710:22;4689:49;;;4683:3;4676:5;4672:15;4665:74;4615:135;4803:2;4836:49;4881:3;4872:6;4861:9;4857:22;4836:49;;;4829:4;4822:5;4818:16;4811:75;4760:137;4953:2;4986:49;5031:3;5022:6;5011:9;5007:22;4986:49;;;4979:4;4972:5;4968:16;4961:75;4907:140;5105:2;5138:49;5183:3;5174:6;5163:9;5159:22;5138:49;;;5131:4;5124:5;5120:16;5113:75;5057:142;5260:3;5294:49;5339:3;5330:6;5319:9;5315:22;5294:49;;;5287:4;5280:5;5276:16;5269:75;5209:146;4515:850;;;;;5411:576;;5530:4;5518:9;5513:3;5509:19;5505:30;5502:2;;;5548:1;5545;5538:12;5502:2;5566:20;5581:4;5566:20;;;5557:29;;5636:1;5667:63;5726:3;5717:6;5706:9;5702:22;5667:63;;;5661:3;5654:5;5650:15;5643:88;5596:146;5820:2;5809:9;5805:18;5792:32;5844:18;5836:6;5833:30;5830:2;;;5876:1;5873;5866:12;5830:2;5911:54;5961:3;5952:6;5941:9;5937:22;5911:54;;;5904:4;5897:5;5893:16;5886:80;5752:225;5496:491;;;;;6028:1305;;6142:4;6130:9;6125:3;6121:19;6117:30;6114:2;;;6160:1;6157;6150:12;6114:2;6178:20;6193:4;6178:20;;;6169:29;;6260:1;6291:49;6336:3;6327:6;6316:9;6312:22;6291:49;;;6285:3;6278:5;6274:15;6267:74;6208:144;6403:2;6436:49;6481:3;6472:6;6461:9;6457:22;6436:49;;;6429:4;6422:5;6418:16;6411:75;6362:135;6555:2;6588:49;6633:3;6624:6;6613:9;6609:22;6588:49;;;6581:4;6574:5;6570:16;6563:75;6507:142;6704:2;6737:49;6782:3;6773:6;6762:9;6758:22;6737:49;;;6730:4;6723:5;6719:16;6712:75;6659:139;6846:3;6880:49;6925:3;6916:6;6905:9;6901:22;6880:49;;;6873:4;6866:5;6862:16;6855:75;6808:133;6992:3;7026:49;7071:3;7062:6;7051:9;7047:22;7026:49;;;7019:4;7012:5;7008:16;7001:75;6951:136;7165:3;7154:9;7150:19;7137:33;7190:18;7182:6;7179:30;7176:2;;;7222:1;7219;7212:12;7176:2;7257:54;7307:3;7298:6;7287:9;7283:22;7257:54;;;7250:4;7243:5;7239:16;7232:80;7097:226;6108:1225;;;;;7340:130;;7420:6;7407:20;7398:29;;7432:33;7459:5;7432:33;;;7392:78;;;;;7477:491;;;;7615:2;7603:9;7594:7;7590:23;7586:32;7583:2;;;7631:1;7628;7621:12;7583:2;7666:1;7683:53;7728:7;7719:6;7708:9;7704:22;7683:53;;;7673:63;;7645:97;7773:2;7791:53;7836:7;7827:6;7816:9;7812:22;7791:53;;;7781:63;;7752:98;7881:2;7899:53;7944:7;7935:6;7924:9;7920:22;7899:53;;;7889:63;;7860:98;7577:391;;;;;;7975:470;;;8105:2;8093:9;8084:7;8080:23;8076:32;8073:2;;;8121:1;8118;8111:12;8073:2;8184:1;8173:9;8169:17;8156:31;8207:18;8199:6;8196:30;8193:2;;;8239:1;8236;8229:12;8193:2;8259:62;8313:7;8304:6;8293:9;8289:22;8259:62;;;8249:72;;8135:192;8358:2;8376:53;8421:7;8412:6;8401:9;8397:22;8376:53;;;8366:63;;8337:98;8067:378;;;;;;8452:1081;;;;;8710:3;8698:9;8689:7;8685:23;8681:33;8678:2;;;8727:1;8724;8717:12;8678:2;8790:1;8779:9;8775:17;8762:31;8813:18;8805:6;8802:30;8799:2;;;8845:1;8842;8835:12;8799:2;8865:62;8919:7;8910:6;8899:9;8895:22;8865:62;;;8855:72;;8741:192;8964:2;8982:53;9027:7;9018:6;9007:9;9003:22;8982:53;;;8972:63;;8943:98;9100:2;9089:9;9085:18;9072:32;9124:18;9116:6;9113:30;9110:2;;;9156:1;9153;9146:12;9110:2;9176:103;9271:7;9262:6;9251:9;9247:22;9176:103;;;9166:113;;9051:234;9344:2;9333:9;9329:18;9316:32;9368:18;9360:6;9357:30;9354:2;;;9400:1;9397;9390:12;9354:2;9420:97;9509:7;9500:6;9489:9;9485:22;9420:97;;;9410:107;;9295:228;8672:861;;;;;;;;9540:994;;;;;9797:3;9785:9;9776:7;9772:23;9768:33;9765:2;;;9814:1;9811;9804:12;9765:2;9877:1;9866:9;9862:17;9849:31;9900:18;9892:6;9889:30;9886:2;;;9932:1;9929;9922:12;9886:2;9952:62;10006:7;9997:6;9986:9;9982:22;9952:62;;;9942:72;;9828:192;10051:2;10069:53;10114:7;10105:6;10094:9;10090:22;10069:53;;;10059:63;;10030:98;10159:2;10177:91;10260:7;10251:6;10240:9;10236:22;10177:91;;;10167:101;;10138:136;10333:3;10322:9;10318:19;10305:33;10358:18;10350:6;10347:30;10344:2;;;10390:1;10387;10380:12;10344:2;10410:108;10510:7;10501:6;10490:9;10486:22;10410:108;;;10400:118;;10284:240;9759:775;;;;;;;;10542:253;;10667:88;10751:3;10743:6;10667:88;;;10784:4;10779:3;10775:14;10761:28;;10660:135;;;;;10804:173;;10891:46;10933:3;10925:6;10891:46;;;10966:4;10961:3;10957:14;10943:28;;10884:93;;;;;10986:277;;11147:110;11253:3;11245:6;11147:110;;;11133:124;;11126:137;;;;;11272:257;;11423:100;11519:3;11511:6;11423:100;;;11409:114;;11402:127;;;;;11537:103;11610:24;11628:5;11610:24;;;11605:3;11598:37;11592:48;;;11647:113;11730:24;11748:5;11730:24;;;11725:3;11718:37;11712:48;;;11767:152;11868:45;11888:24;11906:5;11888:24;;;11868:45;;;11863:3;11856:58;11850:69;;;11963:842;;12146:73;12213:5;12146:73;;;12232:105;12330:6;12325:3;12232:105;;;12225:112;;12358:75;12427:5;12358:75;;;12453:7;12481:1;12466:317;12491:6;12488:1;12485:13;12466:317;;;12558:6;12552:13;12579:101;12676:3;12661:13;12579:101;;;12572:108;;12697:79;12769:6;12697:79;;;12687:89;;12523:260;12513:1;12510;12506:9;12501:14;;12466:317;;;12470:14;12796:3;12789:10;;12125:680;;;;;;;;12846:624;12965:48;13007:5;12965:48;;;13026:74;13093:6;13088:3;13026:74;;;13019:81;;13121:50;13165:5;13121:50;;;13191:7;13219:1;13204:254;13229:6;13226:1;13223:13;13204:254;;;13296:6;13290:13;13317:63;13376:3;13361:13;13317:63;;;13310:70;;13397:54;13444:6;13397:54;;;13387:64;;13261:197;13251:1;13248;13244:9;13239:14;;13204:254;;;13208:14;12944:526;;;;;;13559:1088;;13764:84;13842:5;13764:84;;;13861:116;13970:6;13965:3;13861:116;;;13854:123;;14000:3;14042:4;14034:6;14030:17;14025:3;14021:27;14069:86;14149:5;14069:86;;;14175:7;14203:1;14188:420;14213:6;14210:1;14207:13;14188:420;;;14275:9;14269:4;14265:20;14260:3;14253:33;14320:6;14314:13;14342:124;14461:4;14446:13;14342:124;;;14334:132;;14483:90;14566:6;14483:90;;;14473:100;;14596:4;14591:3;14587:14;14580:21;;14245:363;14235:1;14232;14228:9;14223:14;;14188:420;;;14192:14;14621:4;14614:11;;14638:3;14631:10;;13743:904;;;;;;;;;;14726:1048;;14921:79;14994:5;14921:79;;;15013:111;15117:6;15112:3;15013:111;;;15006:118;;15147:3;15189:4;15181:6;15177:17;15172:3;15168:27;15216:81;15291:5;15216:81;;;15317:7;15345:1;15330:405;15355:6;15352:1;15349:13;15330:405;;;15417:9;15411:4;15407:20;15402:3;15395:33;15462:6;15456:13;15484:114;15593:4;15578:13;15484:114;;;15476:122;;15615:85;15693:6;15615:85;;;15605:95;;15723:4;15718:3;15714:14;15707:21;;15387:348;15377:1;15374;15370:9;15365:14;;15330:405;;;15334:14;15748:4;15741:11;;15765:3;15758:10;;14900:874;;;;;;;;;;15782:148;15881:43;15900:23;15917:5;15900:23;;;15881:43;;;15876:3;15869:56;15863:67;;;15937:103;16010:24;16028:5;16010:24;;;16005:3;15998:37;15992:48;;;16047:152;16148:45;16168:24;16186:5;16168:24;;;16148:45;;;16143:3;16136:58;16130:69;;;16206:315;;16302:34;16330:5;16302:34;;;16348:60;16401:6;16396:3;16348:60;;;16341:67;;16413:52;16458:6;16453:3;16446:4;16439:5;16435:16;16413:52;;;16486:29;16508:6;16486:29;;;16481:3;16477:39;16470:46;;16282:239;;;;;;16528:140;16613:49;16656:5;16613:49;;;16608:3;16601:62;16595:73;;;16676:364;;16836:67;16900:2;16895:3;16836:67;;;16829:74;;16936:66;16932:1;16927:3;16923:11;16916:87;17031:2;17026:3;17022:12;17015:19;;16822:218;;;;17049:364;;17209:67;17273:2;17268:3;17209:67;;;17202:74;;17309:66;17305:1;17300:3;17296:11;17289:87;17404:2;17399:3;17395:12;17388:19;;17195:218;;;;17422:364;;17582:67;17646:2;17641:3;17582:67;;;17575:74;;17682:66;17678:1;17673:3;17669:11;17662:87;17777:2;17772:3;17768:12;17761:19;;17568:218;;;;17877:993;18046:4;18041:3;18037:14;18132:3;18125:5;18121:15;18115:22;18143:62;18200:3;18195;18191:13;18177:12;18143:62;;;18066:145;18287:4;18280:5;18276:16;18270:23;18299:63;18356:4;18351:3;18347:14;18333:12;18299:63;;;18221:147;18447:4;18440:5;18436:16;18430:23;18459:63;18516:4;18511:3;18507:14;18493:12;18459:63;;;18378:150;18609:4;18602:5;18598:16;18592:23;18621:63;18678:4;18673:3;18669:14;18655:12;18621:63;;;18538:152;18774:4;18767:5;18763:16;18757:23;18786:63;18843:4;18838:3;18834:14;18820:12;18786:63;;;18700:155;18019:851;;;;18952:579;;19107:4;19102:3;19098:14;19190:3;19183:5;19179:15;19173:22;19201:74;19270:3;19265;19261:13;19247:12;19201:74;;;19127:154;19354:4;19347:5;19343:16;19337:23;19406:3;19400:4;19396:14;19389:4;19384:3;19380:14;19373:38;19426:67;19488:4;19474:12;19426:67;;;19418:75;;19291:214;19522:4;19515:11;;19080:451;;;;;;19603:1352;;19748:4;19743:3;19739:14;19843:3;19836:5;19832:15;19826:22;19854:62;19911:3;19906;19902:13;19888:12;19854:62;;;19768:154;19996:4;19989:5;19985:16;19979:23;20008:63;20065:4;20060:3;20056:14;20042:12;20008:63;;;19932:145;20158:4;20151:5;20147:16;20141:23;20170:63;20227:4;20222:3;20218:14;20204:12;20170:63;;;20087:152;20317:4;20310:5;20306:16;20300:23;20329:63;20386:4;20381:3;20377:14;20363:12;20329:63;;;20249:149;20469:4;20462:5;20458:16;20452:23;20481:63;20538:4;20533:3;20529:14;20515:12;20481:63;;;20408:142;20624:4;20617:5;20613:16;20607:23;20636:63;20693:4;20688:3;20684:14;20670:12;20636:63;;;20560:145;20778:4;20771:5;20767:16;20761:23;20830:3;20824:4;20820:14;20813:4;20808:3;20804:14;20797:38;20850:67;20912:4;20898:12;20850:67;;;20842:75;;20715:214;20946:4;20939:11;;19721:1234;;;;;;20962:103;21035:24;21053:5;21035:24;;;21030:3;21023:37;21017:48;;;21072:113;21155:24;21173:5;21155:24;;;21150:3;21143:37;21137:48;;;21192:152;21293:45;21313:24;21331:5;21313:24;;;21293:45;;;21288:3;21281:58;21275:69;;;21351:656;;21552:73;21621:3;21612:6;21552:73;;;21647:1;21642:3;21638:11;21631:18;;21660:75;21731:3;21722:6;21660:75;;;21757:2;21752:3;21748:12;21741:19;;21771:75;21842:3;21833:6;21771:75;;;21868:2;21863:3;21859:12;21852:19;;21882:75;21953:3;21944:6;21882:75;;;21979:2;21974:3;21970:12;21963:19;;21999:3;21992:10;;21540:467;;;;;;;;22014:213;;22132:2;22121:9;22117:18;22109:26;;22146:71;22214:1;22203:9;22199:17;22190:6;22146:71;;;22103:124;;;;;22234:324;;22380:2;22369:9;22365:18;22357:26;;22394:71;22462:1;22451:9;22447:17;22438:6;22394:71;;;22476:72;22544:2;22533:9;22529:18;22520:6;22476:72;;;22351:207;;;;;;22565:796;;22899:2;22888:9;22884:18;22876:26;;22949:9;22943:4;22939:20;22935:1;22924:9;22920:17;22913:47;22974:158;23127:4;23118:6;22974:158;;;22966:166;;23180:9;23174:4;23170:20;23165:2;23154:9;23150:18;23143:48;23205:146;23346:4;23337:6;23205:146;;;23197:154;;22870:491;;;;;;23368:407;;23559:2;23548:9;23544:18;23536:26;;23609:9;23603:4;23599:20;23595:1;23584:9;23580:17;23573:47;23634:131;23760:4;23634:131;;;23626:139;;23530:245;;;;23782:407;;23973:2;23962:9;23958:18;23950:26;;24023:9;24017:4;24013:20;24009:1;23998:9;23994:17;23987:47;24048:131;24174:4;24048:131;;;24040:139;;23944:245;;;;24196:407;;24387:2;24376:9;24372:18;24364:26;;24437:9;24431:4;24427:20;24423:1;24412:9;24408:17;24401:47;24462:131;24588:4;24462:131;;;24454:139;;24358:245;;;;24610:746;;24942:3;24931:9;24927:19;24919:27;;24957:147;25101:1;25090:9;25086:17;25077:6;24957:147;;;25153:9;25147:4;25143:20;25137:3;25126:9;25122:19;25115:49;25178:168;25341:4;25332:6;25178:168;;;25170:176;;24913:443;;;;;;25363:256;;25425:2;25419:9;25409:19;;25463:4;25455:6;25451:17;25562:6;25550:10;25547:22;25526:18;25514:10;25511:34;25508:62;25505:2;;;25583:1;25580;25573:12;25505:2;25603:10;25599:2;25592:22;25403:216;;;;;25626:323;;25804:18;25796:6;25793:30;25790:2;;;25836:1;25833;25826:12;25790:2;25871:4;25863:6;25859:17;25851:25;;25934:4;25928;25924:15;25916:23;;25727:222;;;;25956:240;;26109:18;26101:6;26098:30;26095:2;;;26141:1;26138;26131:12;26095:2;26176:4;26168:6;26164:17;26156:25;;26032:164;;;;26203:334;;26392:18;26384:6;26381:30;26378:2;;;26424:1;26421;26414:12;26378:2;26459:4;26451:6;26447:17;26439:25;;26522:4;26516;26512:15;26504:23;;26315:222;;;;26544:329;;26728:18;26720:6;26717:30;26714:2;;;26760:1;26757;26750:12;26714:2;26795:4;26787:6;26783:17;26775:25;;26858:4;26852;26848:15;26840:23;;26651:222;;;;26880:317;;27019:18;27011:6;27008:30;27005:2;;;27051:1;27048;27041:12;27005:2;27118:4;27114:9;27107:4;27099:6;27095:17;27091:33;27083:41;;27182:4;27176;27172:15;27164:23;;26942:255;;;;27204:321;;27347:18;27339:6;27336:30;27333:2;;;27379:1;27376;27369:12;27333:2;27446:4;27442:9;27435:4;27427:6;27423:17;27419:33;27411:41;;27510:4;27504;27500:15;27492:23;;27270:255;;;;27532:170;;27637:3;27629:11;;27675:4;27670:3;27666:14;27658:22;;27623:79;;;;27709:93;;27789:3;27781:11;;27775:27;;;;27809:181;;27925:3;27917:11;;27963:4;27958:3;27954:14;27946:22;;27911:79;;;;27997:176;;28108:3;28100:11;;28146:4;28141:3;28137:14;28129:22;;28094:79;;;;28180:156;;28308:5;28302:12;28292:22;;28273:63;;;;28343:103;;28433:3;28423:13;;28411:35;;;;28453:167;;28592:5;28586:12;28576:22;;28557:63;;;;28627:162;;28761:5;28755:12;28745:22;;28726:63;;;;28796:117;;28885:5;28879:12;28869:22;;28850:63;;;;28920:127;;29037:4;29032:3;29028:14;29020:22;;29014:33;;;;29054:102;;29146:4;29141:3;29137:14;29129:22;;29123:33;;;;29163:138;;29291:4;29286:3;29282:14;29274:22;;29268:33;;;;29308:133;;29431:4;29426:3;29422:14;29414:22;;29408:33;;;;29449:197;;29598:6;29593:3;29586:19;29635:4;29630:3;29626:14;29611:29;;29579:67;;;;;29655:130;;29776:3;29761:18;;29754:31;;;;;29794:208;;29954:6;29949:3;29942:19;29991:4;29986:3;29982:14;29967:29;;29935:67;;;;;30011:203;;30166:6;30161:3;30154:19;30203:4;30198:3;30194:14;30179:29;;30147:67;;;;;30223:152;;30327:6;30322:3;30315:19;30364:4;30359:3;30355:14;30340:29;;30308:67;;;;;30384:163;;30499:6;30494:3;30487:19;30536:4;30531:3;30527:14;30512:29;;30480:67;;;;;30555:91;;30617:24;30635:5;30617:24;;;30606:35;;30600:46;;;;30653:144;;30725:66;30718:5;30714:78;30703:89;;30697:100;;;;30804:72;;30866:5;30855:16;;30849:27;;;;30883:134;;30959:5;30948:16;;30965:47;31006:5;30965:47;;;30942:75;;;;31024:121;;31097:42;31090:5;31086:54;31075:65;;31069:76;;;;31152:72;;31214:5;31203:16;;31197:27;;;;31231:134;;31322:38;31354:5;31322:38;;;31309:51;;31303:62;;;;31373:145;31454:6;31449:3;31444;31431:30;31510:1;31501:6;31496:3;31492:16;31485:27;31424:94;;;;31527:268;31592:1;31599:101;31613:6;31610:1;31607:13;31599:101;;;31689:1;31684:3;31680:11;31674:18;31670:1;31665:3;31661:11;31654:39;31635:2;31632:1;31628:10;31623:15;;31599:101;;;31715:6;31712:1;31709:13;31706:2;;;31780:1;31771:6;31766:3;31762:16;31755:27;31706:2;31576:219;;;;;31803:95;;31867:26;31887:5;31867:26;;;31856:37;;31850:48;;;;31905:73;;31968:5;31957:16;;31951:27;;;;31985:74;;32049:5;32038:16;;32032:27;;;;32066:89;;32130:20;32144:5;32130:20;;;32119:31;;32113:42;;;;32162:74;;32226:5;32215:16;;32209:27;;;;32243:97;;32331:2;32327:7;32322:2;32315:5;32311:14;32307:28;32297:38;;32291:49;;;;32348:94;;32426:5;32422:2;32418:14;32396:36;;32390:52;;;;32450:105;32533:1;32526:5;32523:12;32513:2;;32539:9;32513:2;32507:48;;32562:117;32631:24;32649:5;32631:24;;;32624:5;32621:35;32611:2;;32670:1;32667;32660:12;32611:2;32605:74;;32686:117;32755:24;32773:5;32755:24;;;32748:5;32745:35;32735:2;;32794:1;32791;32784:12;32735:2;32729:74;;32810:108;32893:1;32886:5;32883:12;32873:2;;32909:1;32906;32899:12;32873:2;32867:51;;32925:117;32994:24;33012:5;32994:24;;;32987:5;32984:35;32974:2;;33033:1;33030;33023:12;32974:2;32968:74;

bzzr://39b0e9c85e5498bf44544b51b9192d355431db97c438ddc504543faaa8e8eb47