Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface Receiver    - function onERC721Received(address _op ... interface Callable    - function tokenCallback(address _from, ... interface Router    - function WETH()    - function factory() interface Factory    - function createPair(address, address) interface Pair    - function token0()    - function totalSupply()    - function balanceOf(address)    - function getReserves()  contract Metadata    - function contractURI()    - function baseTokenURI()    - function tokenURI(uint256 _tokenId)  contract OST *    - function mint(address _receiver, uint ...    - function transfer(address _to, uint25 ...    - function approve(address _spender, ui ...    - function transferFrom(address _from, ...    - function transferAndCall(address _to, ...    - function totalSupply()    - function balanceOf(address _user)    - function allowance(address _user, add ...    - function allInfoFor(address _user)    - function _transfer(address _from, add ...  contract OpenseaTraders    - function setOwner(address _owner)    - function setMetadata(Metadata _metada ...    - function claim(uint256 _index, addres ...    - function approve(address _approved, u ...    - function setApprovalForAll(address _o ...    - function transferFrom(address _from, ...    - function safeTransferFrom(address _fr ...    - function safeTransferFrom(address _fr ...    - function name()    - function symbol()    - function contractURI()    - function baseTokenURI()    - function tokenURI(uint256 _tokenId)    - function ostAddress()    - function owner()    - function totalSupply()    - function balanceOf(address _owner)    - function ownerOf(uint256 _tokenId)    - function getApproved(uint256 _tokenId ...    - function isApprovedForAll(address _ow ...    - function tokenByIndex(uint256 _index)    - function tokenOfOwnerByIndex(address ...    - function isClaimed(uint256 _index)    - function getToken(uint256 _tokenId)    - function getTokens(uint256[] memory _ ...    - function getTokensTable(uint256 _limi ...    - function getOwnerTokensTable(address ...    - function allInfoFor(address _owner)    - function _mint(address _receiver)    - function _transfer(address _from, add ...    - function _verify(bytes32[] memory _pr ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-04-04
*/

/*

 ██████╗ ███████╗████████╗
██╔═══██╗██╔════╝╚══██╔══╝
██║   ██║███████╗   ██║   
██║   ██║╚════██║   ██║   
╚██████╔╝███████║   ██║   
 ╚═════╝ ╚══════╝   ╚═╝    

Opensea Traders
An ERC-20 and NFT airdrop for everyone that traded via Opensea in Q1 2021.

Website: https://openseatraders.io/
Created by sol_dev

*/
pragma solidity ^0.5.17;

interface Receiver {
	function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) external returns (bytes4);
}

interface Callable {
	function tokenCallback(address _from, uint256 _tokens, bytes calldata _data) external returns (bool);
}

interface Router {
	function WETH() external pure returns (address);
	function factory() external pure returns (address);
}

interface Factory {
	function createPair(address, address) external returns (address);
}

interface Pair {
	function token0() external view returns (address);
	function totalSupply() external view returns (uint256);
	function balanceOf(address) external view returns (uint256);
	function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}

contract Metadata {
	string public name = "Opensea Traders NFT";
	string public symbol = "OSTNFT";
	function contractURI() external pure returns (string memory) {
		return "https://api.openseatraders.io/metadata";
	}
	function baseTokenURI() public pure returns (string memory) {
		return "https://api.openseatraders.io/token/";
	}
	function tokenURI(uint256 _tokenId) external pure returns (string memory) {
		bytes memory _base = bytes(baseTokenURI());
		uint256 _digits = 1;
		uint256 _n = _tokenId;
		while (_n > 9) {
			_n /= 10;
			_digits++;
		}
		bytes memory _uri = new bytes(_base.length + _digits);
		for (uint256 i = 0; i < _uri.length; i++) {
			if (i < _base.length) {
				_uri[i] = _base[i];
			} else {
				uint256 _dec = (_tokenId / (10**(_uri.length - i - 1))) % 10;
				_uri[i] = byte(uint8(_dec) + 48);
			}
		}
		return string(_uri);
	}
}

contract OST {

	uint256 constant private UINT_MAX = uint256(-1);

	string constant public name = "Opensea Traders";
	string constant public symbol = "OST";
	uint8 constant public decimals = 18;

	struct User {
		uint256 balance;
		mapping(address => uint256) allowance;
	}

	struct Info {
		uint256 totalSupply;
		mapping(address => User) users;
		Router router;
		Pair pair;
		address controller;
		bool weth0;
	}
	Info private info;


	event Transfer(address indexed from, address indexed to, uint256 tokens);
	event Approval(address indexed owner, address indexed spender, uint256 tokens);


	constructor() public {
		info.router = Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
		info.pair = Pair(Factory(info.router.factory()).createPair(info.router.WETH(), address(this)));
		info.weth0 = info.pair.token0() == info.router.WETH();
		info.controller = msg.sender;
	}

	function mint(address _receiver, uint256 _amount) external {
		require(msg.sender == info.controller);
		info.totalSupply += _amount;
		info.users[_receiver].balance += _amount;
		emit Transfer(address(0x0), _receiver, _amount);
	}


	function transfer(address _to, uint256 _tokens) external returns (bool) {
		return _transfer(msg.sender, _to, _tokens);
	}

	function approve(address _spender, uint256 _tokens) external returns (bool) {
		info.users[msg.sender].allowance[_spender] = _tokens;
		emit Approval(msg.sender, _spender, _tokens);
		return true;
	}

	function transferFrom(address _from, address _to, uint256 _tokens) external returns (bool) {
		uint256 _allowance = allowance(_from, msg.sender);
		require(_allowance >= _tokens);
		if (_allowance != UINT_MAX) {
			info.users[_from].allowance[msg.sender] -= _tokens;
		}
		return _transfer(_from, _to, _tokens);
	}

	function transferAndCall(address _to, uint256 _tokens, bytes calldata _data) external returns (bool) {
		_transfer(msg.sender, _to, _tokens);
		uint32 _size;
		assembly {
			_size := extcodesize(_to)
		}
		if (_size > 0) {
			require(Callable(_to).tokenCallback(msg.sender, _tokens, _data));
		}
		return true;
	}
	

	function totalSupply() public view returns (uint256) {
		return info.totalSupply;
	}

	function balanceOf(address _user) public view returns (uint256) {
		return info.users[_user].balance;
	}

	function allowance(address _user, address _spender) public view returns (uint256) {
		return info.users[_user].allowance[_spender];
	}

	function allInfoFor(address _user) external view returns (uint256 totalTokens, uint256 totalLPTokens, uint256 wethReserve, uint256 ostReserve, uint256 userBalance, uint256 userLPBalance) {
		totalTokens = totalSupply();
		totalLPTokens = info.pair.totalSupply();
		(uint256 _res0, uint256 _res1, ) = info.pair.getReserves();
		wethReserve = info.weth0 ? _res0 : _res1;
		ostReserve = info.weth0 ? _res1 : _res0;
		userBalance = balanceOf(_user);
		userLPBalance = info.pair.balanceOf(_user);
	}


	function _transfer(address _from, address _to, uint256 _tokens) internal returns (bool) {
		require(balanceOf(_from) >= _tokens);
		info.users[_from].balance -= _tokens;
		info.users[_to].balance += _tokens;
		emit Transfer(_from, _to, _tokens);
		return true;
	}
}

contract OpenseaTraders {

	struct User {
		uint256[] list;
		mapping(address => bool) approved;
		mapping(uint256 => uint256) indexOf;
	}

	struct Token {
		address owner;
		address approved;
	}

	struct Info {
		bytes32 merkleRoot;
		uint256 totalSupply;
		mapping(uint256 => uint256) claimedBitMap;
		mapping(uint256 => Token) list;
		mapping(address => User) users;
		OST ost;
		Metadata metadata;
		address owner;
	}
	Info private info;

	mapping(bytes4 => bool) public supportsInterface;

	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

	event Claimed(uint256 indexed index, address indexed account, uint256 indexed tokenId);


	constructor(bytes32 _merkleRoot) public {
		info.ost = new OST();
		info.metadata = new Metadata();
		info.owner = msg.sender;
		info.merkleRoot = _merkleRoot;
		supportsInterface[0x01ffc9a7] = true; // ERC-165
		supportsInterface[0x80ac58cd] = true; // ERC-721
		supportsInterface[0x5b5e139f] = true; // Metadata
		supportsInterface[0x780e9d63] = true; // Enumerable

		// Developer Bonus
		info.ost.mint(msg.sender, 1e22); // 10,000 OST
		_mint(msg.sender);
	}

	function setOwner(address _owner) external {
		require(msg.sender == info.owner);
		info.owner = _owner;
	}

	function setMetadata(Metadata _metadata) external {
		require(msg.sender == info.owner);
		info.metadata = _metadata;
	}


	function claim(uint256 _index, address _account, uint256 _amount, bytes32[] calldata _merkleProof) external {
		require(!isClaimed(_index));
		bytes32 _node = keccak256(abi.encodePacked(_index, _account, _amount));
		require(_verify(_merkleProof, _node));
		uint256 _claimedWordIndex = _index / 256;
		uint256 _claimedBitIndex = _index % 256;
		info.claimedBitMap[_claimedWordIndex] = info.claimedBitMap[_claimedWordIndex] | (1 << _claimedBitIndex);
		info.ost.mint(_account, _amount);
		uint256 _tokenId = _mint(_account);
		emit Claimed(_index, _account, _tokenId);
	}
	
	function approve(address _approved, uint256 _tokenId) external {
		require(msg.sender == ownerOf(_tokenId));
		info.list[_tokenId].approved = _approved;
		emit Approval(msg.sender, _approved, _tokenId);
	}

	function setApprovalForAll(address _operator, bool _approved) external {
		info.users[msg.sender].approved[_operator] = _approved;
		emit ApprovalForAll(msg.sender, _operator, _approved);
	}

	function transferFrom(address _from, address _to, uint256 _tokenId) external {
		_transfer(_from, _to, _tokenId);
	}

	function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
		safeTransferFrom(_from, _to, _tokenId, "");
	}

	function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) public {
		_transfer(_from, _to, _tokenId);
		uint32 _size;
		assembly {
			_size := extcodesize(_to)
		}
		if (_size > 0) {
			require(Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data) == 0x150b7a02);
		}
	}


	function name() external view returns (string memory) {
		return info.metadata.name();
	}

	function symbol() external view returns (string memory) {
		return info.metadata.symbol();
	}

	function contractURI() external view returns (string memory) {
		return info.metadata.contractURI();
	}

	function baseTokenURI() external view returns (string memory) {
		return info.metadata.baseTokenURI();
	}

	function tokenURI(uint256 _tokenId) external view returns (string memory) {
		return info.metadata.tokenURI(_tokenId);
	}

	function ostAddress() external view returns (address) {
		return address(info.ost);
	}

	function owner() public view returns (address) {
		return info.owner;
	}

	function totalSupply() public view returns (uint256) {
		return info.totalSupply;
	}

	function balanceOf(address _owner) public view returns (uint256) {
		return info.users[_owner].list.length;
	}

	function ownerOf(uint256 _tokenId) public view returns (address) {
		require(_tokenId != 0 && _tokenId <= totalSupply());
		return info.list[_tokenId].owner;
	}

	function getApproved(uint256 _tokenId) public view returns (address) {
		require(_tokenId != 0 && _tokenId <= totalSupply());
		return info.list[_tokenId].approved;
	}

	function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
		return info.users[_owner].approved[_operator];
	}

	function tokenByIndex(uint256 _index) public view returns (uint256) {
		require(_index < totalSupply());
		return _index;
	}

	function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
		require(_index < balanceOf(_owner));
		return info.users[_owner].list[_index];
	}

	function isClaimed(uint256 _index) public view returns (bool) {
		uint256 _claimedWordIndex = _index / 256;
		uint256 _claimedBitIndex = _index % 256;
		uint256 _claimedWord = info.claimedBitMap[_claimedWordIndex];
		uint256 _mask = (1 << _claimedBitIndex);
		return _claimedWord & _mask == _mask;
	}

	function getToken(uint256 _tokenId) public view returns (address tokenOwner, address approved) {
		return (ownerOf(_tokenId), getApproved(_tokenId));
	}

	function getTokens(uint256[] memory _tokenIds) public view returns (address[] memory owners, address[] memory approveds) {
		uint256 _length = _tokenIds.length;
		owners = new address[](_length);
		approveds = new address[](_length);
		for (uint256 i = 0; i < _length; i++) {
			(owners[i], approveds[i]) = getToken(_tokenIds[i]);
		}
	}

	function getTokensTable(uint256 _limit, uint256 _page, bool _isAsc) public view returns (uint256[] memory tokenIds, address[] memory owners, address[] memory approveds, uint256 totalTokens, uint256 totalPages) {
		require(_limit > 0);
		totalTokens = totalSupply();

		if (totalTokens > 0) {
			totalPages = (totalTokens / _limit) + (totalTokens % _limit == 0 ? 0 : 1);
			require(_page < totalPages);

			uint256 _offset = _limit * _page;
			if (_page == totalPages - 1 && totalTokens % _limit != 0) {
				_limit = totalTokens % _limit;
			}

			tokenIds = new uint256[](_limit);
			for (uint256 i = 0; i < _limit; i++) {
				tokenIds[i] = tokenByIndex(_isAsc ? _offset + i : totalTokens - _offset - i - 1);
			}
		} else {
			totalPages = 0;
			tokenIds = new uint256[](0);
		}
		(owners, approveds) = getTokens(tokenIds);
	}

	function getOwnerTokensTable(address _owner, uint256 _limit, uint256 _page, bool _isAsc) public view returns (uint256[] memory tokenIds, address[] memory approveds, uint256 totalTokens, uint256 totalPages) {
		require(_limit > 0);
		totalTokens = balanceOf(_owner);

		if (totalTokens > 0) {
			totalPages = (totalTokens / _limit) + (totalTokens % _limit == 0 ? 0 : 1);
			require(_page < totalPages);

			uint256 _offset = _limit * _page;
			if (_page == totalPages - 1 && totalTokens % _limit != 0) {
				_limit = totalTokens % _limit;
			}

			tokenIds = new uint256[](_limit);
			for (uint256 i = 0; i < _limit; i++) {
				tokenIds[i] = tokenOfOwnerByIndex(_owner, _isAsc ? _offset + i : totalTokens - _offset - i - 1);
			}
		} else {
			totalPages = 0;
			tokenIds = new uint256[](0);
		}
		( , approveds) = getTokens(tokenIds);
	}

	function allInfoFor(address _owner) external view returns (uint256 supply, uint256 ownerBalance) {
		return (totalSupply(), balanceOf(_owner));
	}


	function _mint(address _receiver) internal returns (uint256 tokenId) {
		tokenId = totalSupply();
		info.totalSupply++;
		info.list[tokenId].owner = _receiver;
		info.users[_receiver].indexOf[tokenId] = info.users[_receiver].list.push(tokenId);
		emit Transfer(address(0x0), _receiver, tokenId);
	}
	
	function _transfer(address _from, address _to, uint256 _tokenId) internal {
		(address _owner, address _approved) = getToken(_tokenId);
		require(_from == _owner);
		require(msg.sender == _owner || msg.sender == _approved || isApprovedForAll(_owner, msg.sender));

		info.list[_tokenId].owner = _to;
		if (_approved != address(0x0)) {
			info.list[_tokenId].approved = address(0x0);
			emit Approval(address(0x0), address(0x0), _tokenId);
		}

		uint256 _index = info.users[_from].indexOf[_tokenId] - 1;
		uint256 _moved = info.users[_from].list[info.users[_from].list.length - 1];
		info.users[_from].list[_index] = _moved;
		info.users[_from].indexOf[_moved] = _index + 1;
		info.users[_from].list.length--;
		delete info.users[_from].indexOf[_tokenId];
		info.users[_to].indexOf[_tokenId] = info.users[_to].list.push(_tokenId);
		emit Transfer(_from, _to, _tokenId);
	}

	function _verify(bytes32[] memory _proof, bytes32 _leaf) internal view returns (bool) {
		bytes32 _computedHash = _leaf;
		for (uint256 i = 0; i < _proof.length; i++) {
			bytes32 _proofElement = _proof[i];
			if (_computedHash <= _proofElement) {
				_computedHash = keccak256(abi.encodePacked(_computedHash, _proofElement));
			} else {
				_computedHash = keccak256(abi.encodePacked(_proofElement, _computedHash));
			}
		}
		return _computedHash == info.merkleRoot;
	}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"Transfer","type":"event"},{"constant":true,"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"allInfoFor","outputs":[{"internalType":"uint256","name":"totalTokens","type":"uint256"},{"internalType":"uint256","name":"totalLPTokens","type":"uint256"},{"internalType":"uint256","name":"wethReserve","type":"uint256"},{"internalType":"uint256","name":"ostReserve","type":"uint256"},{"internalType":"uint256","name":"userBalance","type":"uint256"},{"internalType":"uint256","name":"userLPBalance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"transferAndCall","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

2318:3276:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2318:3276:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2390:47;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;2390:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3605:203;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3605:203:0;;-1:-1:-1;;;;;3605:203:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;4470:86;;;:::i;:::-;;;;;;;;;;;;;;;;3813:321;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;3813:321:0;;;;;;;;;;;;;;;;;:::i;2482:35::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;4139:323;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;4139:323:0;;-1:-1:-1;;;;;4139:323:0;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;4139:323:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;4139:323:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;4139:323:0;;-1:-1:-1;4139:323:0;-1:-1:-1;4139:323:0;:::i;3233:236::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3233:236:0;;-1:-1:-1;;;;;3233:236:0;;;;;;:::i;:::-;;4813:502;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4813:502:0;-1:-1:-1;;;;;4813:502:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4561:106;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4561:106:0;-1:-1:-1;;;;;4561:106:0;;:::i;2441:37::-;;;:::i;3476:124::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3476:124:0;;-1:-1:-1;;;;;3476:124:0;;;;;;:::i;4672:136::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;4672:136:0;;;;;;;;;;:::i;2390:47::-;;;;;;;;;;;;;-1:-1:-1;;;2390:47:0;;;;;:::o;3605:203::-;3697:10;3675:4;3686:22;;;:10;:22;;;;;;;;-1:-1:-1;;;;;3686:42:0;;;;;:32;;:42;;;;;:52;;;3748:39;;;;;;;3675:4;;3686:42;;3748:39;;;;;;;;;;;-1:-1:-1;3799:4:0;3605:203;;;;:::o;4470:86::-;4514:7;4535:16;4470:86;:::o;3813:321::-;3898:4;3909:18;3930:28;3940:5;3947:10;3930:9;:28::i;:::-;3909:49;;3985:7;3971:10;:21;;3963:30;;;;;;-1:-1:-1;;4002:22:0;;3998:90;;-1:-1:-1;;;;;4032:17:0;;:4;:17;;;-1:-1:-1;4032:17:0;;;;;;;;4060:10;4032:39;;:27;;;:39;;;;:50;;;;;;;3998:90;4099:30;4109:5;4116:3;4121:7;4099:9;:30::i;:::-;4092:37;3813:321;-1:-1:-1;;;;;3813:321:0:o;2482:35::-;2515:2;2482:35;:::o;4139:323::-;4234:4;4245:35;4255:10;4267:3;4272:7;4245:9;:35::i;:::-;-1:-1:-1;4326:16:0;;4355:9;;;;4351:91;;4380:55;;-1:-1:-1;;;4380:55:0;;4408:10;4380:55;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4380:27:0;;;-1:-1:-1;;4408:10:0;4380:55;;4429:5;;4380:55;;;;;;4429:5;4380:55;;4429:5;4380:55;1:33:-1;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;4380:55:0;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4380:55:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;4380:55:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4380:55:0;4372:64;;;;;;-1:-1:-1;4453:4:0;;4139:323;-1:-1:-1;;;;;4139:323:0:o;3233:236::-;3319:15;;-1:-1:-1;;;;;3319:15:0;3305:10;:29;3297:38;;;;;;3340:4;:27;;;;;;-1:-1:-1;;;;;3372:21:0;;;;;-1:-1:-1;3372:21:0;;;;;;;;:40;;;;;;3422:42;;;;;;;3372:21;;3340:4;3422:42;;;;;;;;;;;3233:236;;:::o;4813:502::-;4871:19;4892:21;4915:19;4936:18;4956:19;4977:21;5019:13;:11;:13::i;:::-;5053:9;;:23;;;-1:-1:-1;;;5053:23:0;;;;5005:27;;-1:-1:-1;;;;;;5053:9:0;;;;-1:-1:-1;;5053:23:0;;;;;;;;;;;;;;;:9;:23;;;5:2:-1;;;;30:1;27;20:12;5:2;5053:23:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;5053:23:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5053:23:0;5116:9;;:23;;;-1:-1:-1;;;5116:23:0;;;;5053;;-1:-1:-1;5082:13:0;;;;-1:-1:-1;;;;;5116:9:0;;:21;;:23;;;;;;;;;;;;;;:9;:23;;;5:2:-1;;;;30:1;27;20:12;5:2;5116:23:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;5116:23:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5116:23:0;;;;;;;5158:10;;5081:58;;;;;-1:-1:-1;5081:58:0;;;-1:-1:-1;;;;5158:10:0;;;;:26;;5179:5;5158:26;;;5171:5;5158:26;5202:10;;5144:40;;-1:-1:-1;;;;5202:10:0;;;;:26;;5223:5;5202:26;;;5215:5;5202:26;5189:39;;5247:16;5257:5;5247:9;:16::i;:::-;5284:9;;:26;;;-1:-1:-1;;;5284:26:0;;-1:-1:-1;;;;;5284:26:0;;;;;;;;;5233:30;;-1:-1:-1;5284:9:0;;;-1:-1:-1;;5284:26:0;;;;;;;;;;;;;;;:9;:26;;;5:2:-1;;;;30:1;27;20:12;5:2;5284:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;5284:26:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5284:26:0;4813:502;;;;-1:-1:-1;4813:502:0;;;;;;-1:-1:-1;;;4813:502:0:o;4561:106::-;-1:-1:-1;;;;;4637:17:0;4616:7;4637:17;;;-1:-1:-1;4637:17:0;;;;;:25;;4561:106::o;2441:37::-;;;;;;;;;;;;;-1:-1:-1;;;2441:37:0;;;;;:::o;3476:124::-;3542:4;3560:35;3570:10;3582:3;3587:7;3560:9;:35::i;:::-;3553:42;3476:124;-1:-1:-1;;;3476:124:0:o;4672:136::-;-1:-1:-1;;;;;4766:17:0;;;4745:7;4766:17;;;-1:-1:-1;4766:17:0;;;;;;;;:37;;;;;;:27;;:37;;;;;;4672:136::o;5322:269::-;5404:4;5443:7;5423:16;5433:5;5423:9;:16::i;:::-;:27;;5415:36;;;;;;-1:-1:-1;;;;;5456:17:0;;;:4;:17;;;-1:-1:-1;5456:17:0;;;;;;;;:36;;;;;;;5497:15;;;;;;;;;;:34;;;;;;5541:29;;;;;;;5497:15;;5541:29;;;;;;;;;;;-1:-1:-1;5582:4:0;5322:269;;;;;:::o

bzzr://24370630180f238ecdfc4b8a35399defd4d33fac337fcb27c58a934aec7b4d88