Contract 0xb1bcc3bacbbbd02f02f9c1335f79c9dd98684905 1

/**
 *Submitted for verification at hecoinfo.com on 2021-05-10
*/

pragma solidity >=0.5.0 <0.6.0;

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }

    function cbrt(uint256 n) internal pure returns (uint256) {
        if (n == 0) {
            return 0;
        }

        uint256[12] memory divisor =
            [
                uint256(1000000),
                uint256(100000),
                uint256(10000),
                uint256(1000),
                uint256(100),
                uint256(10),
                uint256(9),
                uint256(7),
                uint256(5),
                uint256(3),
                uint256(2),
                uint256(1)
            ];

        uint256[12] memory cube_root =
            [
                uint256(100.000000 * 1e6),
                uint256(46.415888 * 1e6),
                uint256(21.544347 * 1e6),
                uint256(10.000000 * 1e6),
                uint256(4.641589 * 1e6),
                uint256(2.154434 * 1e6),
                uint256(2.080083 * 1e6),
                uint256(1.912931 * 1e6),
                uint256(1.709975 * 1e6),
                uint256(1.442249 * 1e6),
                uint256(1.259921 * 1e6),
                uint256(1.000000 * 1e6)
            ];

        uint256 a = n;
        uint256 r = 1;

        for (uint256 j = 0; j < divisor.length; ) {
            if (a >= divisor[j]) {
                r = (r * cube_root[j]) / 1e6;
                a /= divisor[j];
            } else if (a <= 1) {
                break;
            } else {
                j++;
            }
        }

        return r;
    }
}

contract KTimeController {
    uint256 public offsetTime;

    function timestemp() external view returns (uint256) {
        return now + offsetTime;
    }

    function increaseTime(uint256 t) external {
        offsetTime += t;
    }
}

pragma solidity >=0.5.0 <0.6.0;

contract KOwnerable {
    address[] internal _authAddress = [
        address(0x013a0Fe4a79afFF253Fd0ACBDC891384EBbD0630)
    ];

    address[] public KContractOwners = [
        address(0x013a0Fe4a79afFF253Fd0ACBDC891384EBbD0630)
    ];

    bool private _call_locked;

    constructor() public {
        KContractOwners.push(msg.sender);
        _authAddress.push(msg.sender);
    }

    function KAuthAddresses() external view returns (address[] memory) {
        return _authAddress;
    }

    function KAddAuthAddress(address auther) external KOwnerOnly {
        _authAddress.push(auther);
    }

    function KDelAuthAddress(address auther) external KOwnerOnly {
        for (uint256 i = 0; i < _authAddress.length; i++) {
            if (_authAddress[i] == auther) {
                for (uint256 j = 0; j < _authAddress.length - 1; j++) {
                    _authAddress[j] = _authAddress[j + 1];
                }
                delete _authAddress[_authAddress.length - 1];
                _authAddress.pop();
                return;
            }
        }
    }

    modifier KOwnerOnly() {
        bool exist = false;
        for (uint256 i = 0; i < KContractOwners.length; i++) {
            if (KContractOwners[i] == msg.sender) {
                exist = true;
                break;
            }
        }
        require(exist, "NotAuther");
        _;
    }

    modifier KOwnerOnlyAPI() {
        bool exist = false;
        for (uint256 i = 0; i < KContractOwners.length; i++) {
            if (KContractOwners[i] == msg.sender) {
                exist = true;
                break;
            }
        }
        require(exist, "NotAuther");
        _;
    }

    modifier KRejectContractCall() {
        uint256 size;
        address payable safeAddr = msg.sender;
        assembly {
            size := extcodesize(safeAddr)
        }
        require(size == 0, "Sender Is Contract");
        _;
    }

    modifier KDAODefense() {
        require(!_call_locked, "DAO_Warning");
        _call_locked = true;
        _;
        _call_locked = false;
    }

    modifier KDelegateMethod() {
        bool exist = false;
        for (uint256 i = 0; i < _authAddress.length; i++) {
            if (_authAddress[i] == msg.sender) {
                exist = true;
                break;
            }
        }
        require(exist, "PermissionDeny");
        _;
    }

    function uint2str(uint256 i) internal pure returns (string memory c) {
        if (i == 0) return "0";
        uint256 j = i;
        uint256 length;
        while (j != 0) {
            length++;
            j /= 10;
        }
        bytes memory bstr = new bytes(length);
        uint256 k = length - 1;
        while (i != 0) {
            bstr[k--] = bytes1(uint8(48 + (i % 10)));
            i /= 10;
        }
        c = string(bstr);
    }
}

contract KPausable is KOwnerable {
    event Paused(address account);

    event Unpaused(address account);

    bool public paused;

    constructor() internal {
        paused = false;
    }

    modifier KWhenNotPaused() {
        require(!paused, "Pausable: paused");
        _;
    }

    modifier KWhenPaused() {
        require(paused, "Pausable: not paused");
        _;
    }

    function Pause() public KOwnerOnly {
        paused = true;
        emit Paused(msg.sender);
    }

    function Unpause() public KOwnerOnly {
        paused = false;
        emit Unpaused(msg.sender);
    }
}

contract KDebug is KPausable {
    KTimeController internal debugTimeController;

    function timestempZero() internal view returns (uint256) {
        return (timestemp() / 1 days) * 1 days;
    }

    function timestemp() internal view returns (uint256) {
        if (debugTimeController != KTimeController(0)) {
            return debugTimeController.timestemp();
        } else {
            return now;
        }
    }

    function KSetDebugTimeController(address tc) external KOwnerOnly {
        debugTimeController = KTimeController(tc);
    }
}

contract KStorage is KDebug {
    address public KImplementAddress;

    function SetKImplementAddress(address impl) external KOwnerOnly {
        KImplementAddress = impl;
    }

    function() external {
        address impl_address = KImplementAddress;
        assembly {
            calldatacopy(0x0, 0x0, calldatasize())
            let success := delegatecall(
                sub(gas(), 10000),
                impl_address,
                0x0,
                calldatasize(),
                0,
                0
            )
            let retSz := returndatasize()
            returndatacopy(0, 0, retSz)
            switch success
                case 0 {
                    revert(0, retSz)
                }
                default {
                    return(0, retSz)
                }
        }
    }
}

contract KStoragePayable is KDebug {
    address public KImplementAddress;

    function SetKImplementAddress(address impl) external KOwnerOnly {
        KImplementAddress = impl;
    }

    function() external payable {
        address impl_address = KImplementAddress;
        assembly {
            if eq(calldatasize(), 0) {
                return(0, 0)
            }

            calldatacopy(0x0, 0x0, calldatasize())
            let success := delegatecall(
                gas(),
                impl_address,
                0x0,
                calldatasize(),
                0,
                0
            )
            let retSz := returndatasize()
            returndatacopy(0, 0, retSz)
            switch success
                case 0 {
                    revert(0, retSz)
                }
                default {
                    return(0, retSz)
                }
        }
    }
}

pragma solidity >=0.5.0 <0.6.0;

pragma solidity >=0.5.1 <0.7.0;

interface iERC777_1 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    function increaseAllowance(address spender, uint256 addedValue)
        external
        returns (bool);

    function decreaseAllowance(address spender, uint256 subtractedValue)
        external
        returns (bool);

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

    function granularity() external view returns (uint256);

    function defaultOperators() external view returns (address[] memory);

    function addDefaultOperators(address owner) external returns (bool);

    function removeDefaultOperators(address owner) external returns (bool);

    function isOperatorFor(address operator, address holder)
        external
        view
        returns (bool);

    function authorizeOperator(address operator) external;

    function revokeOperator(address operator) external;

    function send(
        address to,
        uint256 amount,
        bytes calldata data
    ) external;

    function operatorSend(
        address from,
        address to,
        uint256 amount,
        bytes calldata data,
        bytes calldata operatorData
    ) external;

    function burn(uint256 amount, bytes calldata data) external;

    function operatorBurn(
        address from,
        uint256 amount,
        bytes calldata data,
        bytes calldata operatorData
    ) external;

    event Sent(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 amount,
        bytes data,
        bytes operatorData
    );
    event Minted(
        address indexed operator,
        address indexed to,
        uint256 amount,
        bytes data,
        bytes operatorData
    );
    event Burned(
        address indexed operator,
        address indexed from,
        uint256 amount,
        bytes data,
        bytes operatorData
    );
    event AuthorizedOperator(address indexed operator, address indexed holder);
    event RevokedOperator(address indexed operator, address indexed holder);
}

pragma solidity >=0.5.1 <0.6.0;

contract ERC777_1TokenStorage is KStorage {
    using SafeMath for uint256;

    address[] internal _defaultOperators;

    mapping(address => uint256) internal _balances;
    mapping(address => mapping(address => uint256)) internal _allowances;
    mapping(address => mapping(address => bool)) internal _authorized;

    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;
    uint256 public granularity = 1;

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        uint256 _totalSupply
    ) public {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        totalSupply = _totalSupply;

        _balances[msg.sender] = _totalSupply;
        _defaultOperators.push(msg.sender);
    }
}

contract ERC777_1Token is iERC777_1, ERC777_1TokenStorage {
    constructor() public ERC777_1TokenStorage("", "", 0, 0) {}

    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }

    function allowance(address owner, address spender)
        external
        view
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    function transfer(address recipient, uint256 amount)
        external
        KWhenNotPaused
        returns (bool)
    {
        _send(msg.sender, recipient, amount, "", msg.sender, "");
        return true;
    }

    function approve(address spender, uint256 value)
        external
        KWhenNotPaused
        returns (bool)
    {
        _approve(msg.sender, spender, value);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external KWhenNotPaused returns (bool) {
        require(amount <= _allowances[sender][msg.sender]);
        _allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(
            amount
        );
        _send(sender, recipient, amount, "", msg.sender, "");
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue)
        external
        KWhenNotPaused
        returns (bool)
    {
        _approve(
            msg.sender,
            spender,
            _allowances[msg.sender][spender].add(addedValue)
        );
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue)
        external
        KWhenNotPaused
        returns (bool)
    {
        _approve(
            msg.sender,
            spender,
            _allowances[msg.sender][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }

    function addDefaultOperators(address owner)
        external
        KOwnerOnly
        returns (bool)
    {
        _defaultOperators.push(owner);
    }

    function removeDefaultOperators(address owner)
        external
        KOwnerOnly
        returns (bool)
    {
        for (uint256 i = 0; i < _defaultOperators.length; i++) {
            if (_defaultOperators[i] == owner) {
                for (uint256 j = i; j < _defaultOperators.length - 1; j++) {
                    _defaultOperators[j] = _defaultOperators[j + 1];
                }
                delete _defaultOperators[_defaultOperators.length - 1];
                _defaultOperators.length--;
                return true;
            }
        }
        return false;
    }

    function defaultOperators() external view returns (address[] memory) {
        return _defaultOperators;
    }

    function authorizeOperator(address _operator) external {
        require(_operator != msg.sender);
        _authorized[_operator][msg.sender] = true;
        emit AuthorizedOperator(_operator, msg.sender);
    }

    function revokeOperator(address _operator) external {
        require(_operator != msg.sender);
        _authorized[_operator][msg.sender] = false;
        emit RevokedOperator(_operator, msg.sender);
    }

    function send(
        address _to,
        uint256 _amount,
        bytes calldata _userData
    ) external {
        _send(msg.sender, _to, _amount, _userData, msg.sender, "");
    }

    function isOperatorFor(address _operator, address _tokenHolder)
        public
        view
        returns (bool)
    {
        for (uint256 i = 0; i < _defaultOperators.length; i++) {
            if (_defaultOperators[i] == _operator) {
                return true;
            }
        }
        return
            _operator == _tokenHolder || _authorized[_operator][_tokenHolder];
    }

    function operatorSend(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _userData,
        bytes calldata _operatorData
    ) external {
        require(isOperatorFor(msg.sender, _from), "NotAuthorized");
        _send(_from, _to, _amount, _userData, msg.sender, _operatorData);
    }

    function mint(
        address _tokenHolder,
        uint256 _amount,
        bytes calldata _operatorData
    ) external KOwnerOnly {
        totalSupply = totalSupply.add(_amount);
        _balances[_tokenHolder] = _balances[_tokenHolder].add(_amount);
        emit Minted(msg.sender, _tokenHolder, _amount, "", _operatorData);
    }

    function burn(uint256 _amount, bytes calldata _data) external {
        _send(msg.sender, address(0x0), _amount, _data, msg.sender, "");
    }

    function operatorBurn(
        address _from,
        uint256 _amount,
        bytes calldata _data,
        bytes calldata _operatorData
    ) external {
        require(isOperatorFor(msg.sender, _from), "NotAuthorized");

        if (totalSupply <= 10000000e6) {
            _send(
                _from,
                KContractOwners[0],
                _amount,
                _data,
                msg.sender,
                _operatorData
            );
        } else {
            _send(
                _from,
                address(0x0),
                _amount,
                _data,
                msg.sender,
                _operatorData
            );
        }
    }

    function _send(
        address _from,
        address _to,
        uint256 _amount,
        bytes memory _userData,
        address _operator,
        bytes memory _operatorData
    ) internal {
        require(_balances[_from] >= _amount);
        _balances[_from] = _balances[_from].sub(_amount);
        _balances[_to] = _balances[_to].add(_amount);

        if (_to == address(0)) {
            totalSupply -= _amount;
            emit Burned(_operator, _from, _amount, _userData, _operatorData);
        } else {
            emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
        }

        emit Transfer(_from, _to, _amount);
    }

    function _approve(
        address owner,
        address spender,
        uint256 value
    ) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = value;
        emit Approval(owner, spender, value);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint8","name":"_decimals","type":"uint8"},{"internalType":"uint256","name":"_totalSupply","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"payable":false,"stateMutability":"nonpayable","type":"fallback"},{"constant":false,"inputs":[{"internalType":"address","name":"auther","type":"address"}],"name":"KAddAuthAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"KAuthAddresses","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"KContractOwners","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"auther","type":"address"}],"name":"KDelAuthAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"KImplementAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tc","type":"address"}],"name":"KSetDebugTimeController","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"Pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"impl","type":"address"}],"name":"SetKImplementAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"Unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"granularity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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"}]

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000033b2e3c9fd0803ce80000000000000000000000000000000000000000000000000000000000000000000003555043000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035550430000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): UPC
Arg [1] : _symbol (string): UPC
Arg [2] : _decimals (uint8): 18
Arg [3] : _totalSupply (uint256): 1000000000000000000000000000

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [3] : 0000000000000000000000000000000000000000033b2e3c9fd0803ce8000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [5] : 5550430000000000000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [7] : 5550430000000000000000000000000000000000000000000000000000000000

12458:856:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12458:856:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7821:17;;;;7896:14;7798:20;;7873:38;8113:1;8093;8060:14;8038:3;8007:12;7982:5;7975;7971:17;7940:189;8156:16;8207:5;8204:1;8201;8186:27;8234:7;8259:65;;;;8383:5;8380:1;8373:16;8259:65;8299:5;8296:1;8289:16;4042:479;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4042:479:0;;;;:::i;:::-;;12789:18;;;:::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;12789:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12874:26;;;:::i;:::-;;;;;;;;;;;;;;;;12841;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3929:105;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3929:105:0;;;;:::i;7611:32::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3549:104;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3549:104:0;;:::i;12907:30::-;;;:::i;6484:18::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;6777:101;;;:::i;7444:125::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7444:125:0;;;;:::i;6886:106::-;;;:::i;7652:107::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7652:107:0;;;;:::i;12814:20::-;;;:::i;3816:105::-;;;:::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;3816:105:0;;;;;;;;;;;;;;;;;4042:479;4562:10;;4591:188;4615:15;:22;4611:26;;4591:188;;;4685:10;4663:32;;:15;4679:1;4663:18;;;;;;;;;;;;;;;;;;;;:32;4659:109;;;4724:4;4716:12;;4747:5;;4659:109;4639:3;;4591:188;;;;4797:5;4789:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4119:9;4114:400;4138:12;:19;4134:23;;4114:400;;;4202:6;4183:25;;:12;4196:1;4183:15;;;;;;;;;;;;;;;;;;;;:25;4179:324;;;4234:9;4229:134;4253:12;:19;-1:-1:-1;;4253:23:0;4249:27;;4229:134;;;4324:12;4337:1;4341;4337:5;4324:19;;;;;;;;;;;;;;;;;4306:15;;4324:19;;;;;;4319:1;;4306:15;;;;;;;;;;;;;;;:37;;-1:-1:-1;;4306:37:0;;;;;;;;;;;;-1:-1:-1;4278:3:0;4229:134;;;-1:-1:-1;4388:12:0;4401:19;;-1:-1:-1;;4401:23:0;;;4388:37;;;;;;;;;;;;;;4381:44;;-1:-1:-1;;4381:44:0;;;4444:18;;;;;;;;;;;;;;;;-1:-1:-1;;4444:18:0;;;;;-1:-1:-1;;4444:18:0;;;;;;-1:-1:-1;4481:7:0;;4179:324;4159:3;;4114:400;;;;4827:1;4042:479;;:::o;12789:18::-;;;;;;;;;;;;;;;-1:-1:-1;;12789:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;12874:26::-;;;;:::o;12841:::-;;;;;;:::o;3929:105::-;4562:10;;4591:188;4615:15;:22;4611:26;;4591:188;;;4685:10;4663:32;;:15;4679:1;4663:18;;;;;;;;;;;;;;;;;;;;:32;4659:109;;;4724:4;4716:12;;4747:5;;4659:109;4639:3;;4591:188;;;;4797:5;4789:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4001:12:0;27:10:-1;;39:1;23:18;;45:23;;4001:25:0;;;;;;;-1:-1:-1;;4001:25:0;;;;;;;;;;;;3929:105::o;7611:32::-;;;;;;:::o;3549:104::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3549:104:0;:::o;12907:30::-;;;;:::o;6484:18::-;;;;;;;;;:::o;6777:101::-;4562:10;;4591:188;4615:15;:22;4611:26;;4591:188;;;4685:10;4663:32;;:15;4679:1;4663:18;;;;;;;;;;;;;;;;;;;;:32;4659:109;;;4724:4;4716:12;;4747:5;;4659:109;4639:3;;4591:188;;;;4797:5;4789:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6823:6;:13;;-1:-1:-1;;6823:13:0;;;;;6852:18;;;6859:10;6852:18;;;;;;;;;;;;;6777:101;:::o;7444:125::-;4562:10;;4591:188;4615:15;:22;4611:26;;4591:188;;;4685:10;4663:32;;:15;4679:1;4663:18;;;;;;;;;;;;;;;;;;;;:32;4659:109;;;4724:4;4716:12;;4747:5;;4659:109;4639:3;;4591:188;;;;4797:5;4789:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7520:19:0;:41;;;;;;;;;;;;;;;;;;7444:125::o;6886:106::-;4562:10;;4591:188;4615:15;:22;4611:26;;4591:188;;;4685:10;4663:32;;:15;4679:1;4663:18;;;;;;;;;;;;;;;;;;;;:32;4659:109;;;4724:4;4716:12;;4747:5;;4659:109;4639:3;;4591:188;;;;4797:5;4789:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6934:6;:14;;-1:-1:-1;;6934:14:0;;;6964:20;;;6973:10;6964:20;;;;;;;;;;;;;6886:106;:::o;7652:107::-;4562:10;;4591:188;4615:15;:22;4611:26;;4591:188;;;4685:10;4663:32;;:15;4679:1;4663:18;;;;;;;;;;;;;;;;;;;;:32;4659:109;;;4724:4;4716:12;;4747:5;;4659:109;4639:3;;4591:188;;;;4797:5;4789:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7727:17:0;:24;;-1:-1:-1;;7727:24:0;;;;;;;;;;;;7652:107::o;12814:20::-;;;;;;;;;;;;;;;-1:-1:-1;;12814:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3816:105;3865:16;3901:12;3894:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3816:105;:::o

bzzr://530e19b1e14ee9a7156fb4ba00b4c1eb195b1e99144998bda10594c2eeb78edd