Contract 0x84aC94F17622241f313511B629e5E98f489AD6E4 1

 
 
Txn Hash
Method
Block
From
To
Value
0x8d644306baa8b3a8609899b2b4fff9e3d10868475bb3b99c66095d3c8111e7eeSet Approval For...142405432022-02-20 3:32:59290 days 7 hrs ago0x114fc8386fdc28bc6bc00a7b0f5c5e40142edb5e IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.00190116 70.42665649
0x1019e35ab5a6c8456d05b76143aee6652b8d7e9851cdca4c939a516b2b0ad801Set Approval For...142163232022-02-16 9:25:27294 days 1 hr agoENS Name notenough.eth IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.00176473 36.07160079
0x61a419f7b615f4628d3c45619174cdb7041d8c7b28d7eb3f91b99ca0b9ec8183Set Approval For...142139402022-02-16 0:22:12294 days 10 hrs ago0x90e6369d65143c77670b4eab6f4151664cd0fa8f IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.00615708 212.14508429
0xfd3014ff3d11645af25756491dec5dfd971acc5a5c3b5d3e250dc2dc1746043bSet Approval For...142139372022-02-16 0:20:56294 days 10 hrs ago0x90e6369d65143c77670b4eab6f4151664cd0fa8f IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.00832726 170.21156383
0xeeecef17689c80495b6568a47d4b518a9f5624932d5c72e1cffb3edd3ffb1f15Cozy Time117378242021-01-27 12:26:04678 days 22 hrs ago0x631afa34adc78513a2a9a0c5227f2aeeb444d9ff IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.00427595
0xc0c2973df43daac78e99eaf74b6aec401ea52c1bb8ce13d745fcd0ad0f79821aTransfer117378122021-01-27 12:23:39678 days 22 hrs ago0xdafa3fb012907378121dd6cc3b16eccf0ad3560e IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.0085180755.00000145
0x02f67e97d379f2e4c0e30b35901c52575af1755f0b9b73de5d9b55d03ae14fd7Transfer112899282020-11-19 17:50:06747 days 17 hrs ago0xf3b02c6df19e6d1fad2ce2b5a463c3cb253194e1 IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.0005032420
0xce51b230e4d0d1c25fd1f793a85068a67788cc9e3bad09ac02ad98246a74b5e6Transfer112887092020-11-19 13:31:10747 days 21 hrs ago0xf3b02c6df19e6d1fad2ce2b5a463c3cb253194e1 IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000866738
0xc0f2466c853b8876204d931646434dc1e907f2ff43583e3c7d9274926949f003Transfer And Auc...112308052020-11-10 16:18:39756 days 18 hrs ago0xdafa3fb012907378121dd6cc3b16eccf0ad3560e IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.0112114232
0xbb321366249394dd80f4cd4d03517241b0e3f63c954d7054da9ffd7ddb7f1775Transfer109332492020-09-25 17:54:27802 days 16 hrs ago0x90e6369d65143c77670b4eab6f4151664cd0fa8f IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.0025174100
0x07c5fcea8549168ca7845638a36e6b8f04df13aa2ecbf553f1a04c24aa40cf61Set Approval For...93310542020-01-22 11:11:191049 days 23 hrs agoENS Name rektum.eth IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000185294
0x669dae79889e2ed0236c812e322071b410c5c3ccce2e019876b8eab7af69d42fSet Approval For...89947482019-11-24 21:33:391108 days 13 hrs ago0x2c0d351e5b58722676da689a4c2b7cfe68a6052e IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000371388
0xb10094810b2ce4f92791dc88df2f66a977b178ce23e40dc1aacc9655ea3ddbecSet Approval For...88495022019-11-01 0:04:221132 days 10 hrs ago0x7c4aadec857e13e4a5642b4041a2f36274ffe8ce IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000185694
0x340f9bcca5148650b63793ba5f5fa7eba7a77da0bbfb12c9d6c5caedc1c6ee14Set Approval For...84931832019-09-06 0:11:501188 days 10 hrs ago0x114fc8386fdc28bc6bc00a7b0f5c5e40142edb5e IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000168393.62737642
0xfdbc545fafa1f86d5721e7b0d90b83325c2bcd033ea7b2203879410d99f70c71Transfer And Auc...83392902019-08-13 1:42:201212 days 9 hrs ago0xdf9bba85383a98cb3c2c82112d3b9808b00ad73a IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000029610.2
0x057349578874814802879edcc719fe847117a460d8f35b118aa562b45aa588f5Transfer And Auc...83385142019-08-12 22:47:071212 days 12 hrs ago0xdf9bba85383a98cb3c2c82112d3b9808b00ad73a IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000057570.34
0xa4fefcf0173b799b36894de88e0fbb4aefd62ae8977b0a949c97a6be9582b5abTransfer And Auc...83385082019-08-12 22:45:341212 days 12 hrs ago0xdf9bba85383a98cb3c2c82112d3b9808b00ad73a IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000086290.51
0x7d84c34ece2c8277679dfcbd534d4b9c1c6b98cbef031582a73fc82505692d1dClaim Username82367542019-07-28 3:44:361228 days 7 hrs ago0xd7242a4eb63aca04ad5e0113b73480c8eba81489 IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000065721
0x9bd933daeb36e25bb51ded5a7770a149ce6ab84c3b920d89e75ca9a79878ea00Transfer And Auc...81366022019-07-12 13:41:121243 days 21 hrs ago0x7288d7e5c545ea78ce19cdcf20589e03f4666fb1 IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000514133
0xdedd51952ca5d45a5f8c17ca6e2466ee724d81f776eb572758fa7624e05460f3Transfer And Auc...81332122019-07-12 0:45:581244 days 10 hrs ago0x7288d7e5c545ea78ce19cdcf20589e03f4666fb1 IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.00017571
0xe5f1c4ccb5128b564b6b94914a7ed1a156e94f53a09a422e5883f97eb8c96145Transfer And Auc...81329692019-07-11 23:55:211244 days 10 hrs ago0x7288d7e5c545ea78ce19cdcf20589e03f4666fb1 IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000168671
0xe63de209864431b4c12c426c6d512960147584ade849004f2630d6e2f21df009Transfer And Auc...81329692019-07-11 23:55:211244 days 10 hrs ago0x7288d7e5c545ea78ce19cdcf20589e03f4666fb1 IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000176241
0xcae04fc655d1261c267cd5924c575356d8180559a7f0b1f1715f0ad467494a13Transfer And Auc...81329302019-07-11 23:46:001244 days 11 hrs ago0x7288d7e5c545ea78ce19cdcf20589e03f4666fb1 IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.00039432.30894518
0x448eb2cca4b552e390f42186ad2c971b35550649ba83ad327910fef12aa3a7fcTransfer And Auc...79561992019-06-14 10:21:131272 days 33 mins ago0x6b3f1e651bd09b150b09c15a01f6689fb57629bb IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000346252
0xb44ae6b3c70f7d2f4f192d0edaba725547b2febaf87eefe1fecf23ac47c70712Transfer And Auc...79561932019-06-14 10:20:211272 days 33 mins ago0x6b3f1e651bd09b150b09c15a01f6689fb57629bb IN  0x84ac94f17622241f313511b629e5e98f489ad6e40 Ether0.000344092
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0xc5f911fce77ffa04da7d7cd4d749e67eabdef5b482e3ae9004e67df04e96fff068749042018-12-12 20:19:311455 days 14 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.05 Ether
0x681319f10924a31f34b7975e33edc8e22d62fcf86f437a25be2dbfbcb2e0daa867291882018-11-18 19:24:051479 days 15 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.029 Ether
0x2652b516fec8b1ff74f8d9e9035a66f078325f23fbe48c67db8eb27a29e369a166870492018-11-11 22:07:311486 days 12 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.0431 Ether
0x72b7dd7e506d5777873fc7cf479fae16d78c38279961f857ac23cc68ebc8add966749432018-11-09 22:39:291488 days 12 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.032 Ether
0xf8bced449f7a7faf4a60e280926bcf02f038e623d3dcba60cc58dd56b5fc26d966522752018-11-06 5:29:001492 days 5 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.00136 Ether
0xbd43adcb7bc931e723f76f80ecd30e2e977dd771713beec3e72f9b976514b4ad66426692018-11-04 15:18:321493 days 19 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.05 Ether
0xb2cd962b826267d16f5dabb62b46b057abc510c77e871211fe972e10cd6ab16d66189872018-10-31 18:10:411497 days 16 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.0342 Ether
0xe909ea2f3170e6e49b8018fc6127638ce95537172dcacb93db044db36086446e66189012018-10-31 17:52:451497 days 17 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.08646 Ether
0xefdb864aea7f9e2451060ea255d9150a543a00ed1ee5347948bac55cac38b52f66047912018-10-29 10:29:081500 days 25 mins ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.015 Ether
0x872bb907dbc161a7804ba897216bcb0ee0557b09cdaa8b83d66cd08c51657ebe65998512018-10-28 14:56:521500 days 19 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.03625 Ether
0xe7b4fc9d6a861c787235661ffbce8a35cac2031e66f2c3d7740bc2e8106bd35a65993702018-10-28 12:56:281500 days 21 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.0119 Ether
0x1676b125446ed64392dbe003d77c5fe219557f46ed2f6b89f81f53a07735f76065993642018-10-28 12:54:541500 days 21 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.012 Ether
0x924b27ae8ec91d81c890d8991bcecb67af1cc7c3cefcdd24a156db56c81367b165993172018-10-28 12:41:571500 days 22 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.01215 Ether
0x4dd56646d8ac8ff5f3811cf8d7967b104a14f15e2a29f9b3fc9bad57b8696bed65830642018-10-25 21:01:431503 days 13 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.0318 Ether
0xc84920def5a1ff53ec80100d32763f9dc610c02f2c3984232136445fcb67c7e365725572018-10-24 3:56:411505 days 6 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.02571 Ether
0xe937207785c8cf35fa0c9be084a5aae140fa33a16ad2ffc283beb7f5f8a29e6d65682302018-10-23 10:56:201505 days 23 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.03041 Ether
0x4058869eb05f19146ea380686ff1d2970fa0ffd0a1ae8bb63959d439c2e9dd0865675872018-10-23 8:24:401506 days 2 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.0171 Ether
0x9d126e4da3cf7ea9fcd519627e605bee5a21721056480e7173d26371d21cff2465656952018-10-23 1:07:071506 days 9 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.02395 Ether
0x54fbf40e693ff10af62a5c78661a024228ea12622ed971ee424adad9474b20cf65608602018-10-22 6:02:481507 days 4 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.08864085 Ether
0x89224b977b72ceafeb3df4c00eb9c94be57f6dfb0879266b3f49cba55670c2f365605632018-10-22 4:49:361507 days 6 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.0214 Ether
0xe04efdadcf68bbd5096839511b06c20c42b3bbd154d17312c581d61b11647f0765580842018-10-21 19:17:011507 days 15 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.02066 Ether
0x939476330fd0a6825483f2ef5dd52b35732462502539868940c5aa100469cb4465561492018-10-21 11:33:501507 days 23 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.02029 Ether
0xa93e3dfcc46aea5bb4920d1c80121ce0921107332354441372f4fe50b7990b8365556052018-10-21 9:20:571508 days 1 hr ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.01616 Ether
0xcbfc2abc491cf6c9886eeef565409f1f85306f79bee522850b8e5ab6cdb8473565553642018-10-21 8:31:471508 days 2 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.038 Ether
0x00f7458e12f72f4eb149e411f94effe80a8e635788e07726b9ae013de647743b65551892018-10-21 7:50:561508 days 3 hrs ago 0x84ac94f17622241f313511b629e5e98f489ad6e4 0xe2c43d2c6d6875c8f24855054d77b5664c7e810f0.0157 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
PepeBase

Compiler Version
v0.4.25+commit.59dbf8f1

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2018-10-09
*/

pragma solidity ^0.4.24;

// File: contracts/Genetic.sol

// solhint-disable-next-line
pragma solidity ^0.4.23;


contract Genetic {

    // TODO mutations
    // maximum number of random mutations per chromatid
    uint8 public constant R = 5;

    // solhint-disable-next-line function-max-lines
    function breed(uint256[2] mother, uint256[2] father, uint256 seed) internal view returns (uint256[2] memOffset) {
        // Meiosis I: recombining alleles (Chromosomal crossovers)

        // Note about optimization I: no cell duplication,
        //  producing 2 seeds/eggs per cell is enough, instead of 4 (like humans do)

        // Note about optimization II: crossovers happen,
        //  but only 1 side of the result is computed,
        //  as the other side will not affect anything.

        // solhint-disable-next-line no-inline-assembly
        assembly {
            // allocate output
            // 1) get the pointer to our memory
            memOffset := mload(0x40)
            // 2) Change the free-memory pointer to keep our memory
            //     (we will only use 64 bytes: 2 values of 256 bits)
            mstore(0x40, add(memOffset, 64))


            // Put seed in scratchpad 0
            mstore(0x0, seed)
            // Also use the timestamp, best we could do to increase randomness
            //  without increasing costs dramatically. (Trade-off)
            mstore(0x20, timestamp)

            // Hash it for a universally random bitstring.
            let hash := keccak256(0, 64)

            // Byzantium VM does not support shift opcodes, will be introduced in Constantinople.
            // Soldity itself, in non-assembly, also just uses other opcodes to simulate it.
            // Optmizer should take care of inlining, just declare shiftR ourselves here.
            // Where possible, better optimization is applied to make it cheaper.
            function shiftR(value, offset) -> result {
                result := div(value, exp(2, offset))
            }

            // solhint-disable max-line-length
            // m_context << Instruction::SWAP1 << u256(2) << Instruction::EXP << Instruction::SWAP1 << (c_leftSigned ? Instruction::SDIV : Instruction::DIV);

            // optimization: although one side consists of multiple chromatids,
            //  we handle them just as one long chromatid:
            //  only difference is that a crossover in chromatid i affects chromatid i+1.
            //  No big deal, order and location is random anyway
            function processSide(fatherSrc, motherSrc, rngSrc) -> result {

                {
                    // initial rngSrc bit length: 254 bits

                    // Run the crossovers
                    // =====================================================

                    // Pick some crossovers
                    // Each crossover is spaced ~64 bits on average.
                    // To achieve this, we get a random 7 bit number, [0, 128), for each crossover.

                    // 256 / 64 = 4, we need 4 crossovers,
                    //  and will have 256 / 127 = 2 at least (rounded down).

                    // Get one bit determining if we should pick DNA from the father,
                    //  or from the mother.
                    // This changes every crossover. (by swapping father and mother)
                    {
                        if eq(and(rngSrc, 0x1), 0) {
                            // Swap mother and father,
                            // create a temporary variable (code golf XOR swap costs more in gas)
                            let temp := fatherSrc
                            fatherSrc := motherSrc
                            motherSrc := temp
                        }

                        // remove the bit from rng source, 253 rng bits left
                        rngSrc := shiftR(rngSrc, 1)
                    }

                    // Don't push/pop this all the time, we have just enough space on stack.
                    let mask := 0

                    // Cap at 4 crossovers, no more than that.
                    let cap := 0
                    let crossoverLen := and(rngSrc, 0x7f) // bin: 1111111 (7 bits ON)
                    // remove bits from hash, e.g. 254 - 7 = 247 left.
                    rngSrc := shiftR(rngSrc, 7)
                    let crossoverPos := crossoverLen

                    // optimization: instead of shifting with an opcode we don't have until Constantinople,
                    //  keep track of the a shifted number, updated using multiplications.
                    let crossoverPosLeading1 := 1

                    // solhint-disable-next-line no-empty-blocks
                    for { } and(lt(crossoverPos, 256), lt(cap, 4)) {

                        crossoverLen := and(rngSrc, 0x7f) // bin: 1111111 (7 bits ON)
                        // remove bits from hash, e.g. 254 - 7 = 247 left.
                        rngSrc := shiftR(rngSrc, 7)

                        crossoverPos := add(crossoverPos, crossoverLen)

                        cap := add(cap, 1)
                    } {

                        // Note: we go from right to left in the bit-string.

                        // Create a mask for this crossover.
                        // Example:
                        // 00000000000001111111111111111110000000000000000000000000000000000000000000000000000000000.....
                        // |Prev. data ||Crossover here  ||remaining data .......
                        //
                        // The crossover part is copied from the mother/father to the child.

                        // Create the bit-mask
                        // Create a bitstring that ignores the previous data:
                        // 00000000000001111111111111111111111111111111111111111111111111111111111111111111111111111.....
                        // First create a leading 1, just before the crossover, like:
                        // 00000000000010000000000000000000000000000000000000000000000000000000000.....
                        // Then substract 1, to get a long string of 1s
                        // 00000000000001111111111111111111111111111111111111111111111111111111111111111111111111111.....
                        // Now do the same for the remain part, and xor it.
                        // leading 1
                        // 00000000000000000000000000000010000000000000000000000000000000000000000000000000000000000.....
                        // sub 1
                        // 00000000000000000000000000000001111111111111111111111111111111111111111111111111111111111.....
                        // xor with other
                        // 00000000000001111111111111111111111111111111111111111111111111111111111111111111111111111.....
                        // 00000000000000000000000000000001111111111111111111111111111111111111111111111111111111111.....
                        // 00000000000001111111111111111110000000000000000000000000000000000000000000000000000000000.....

                        // Use the final shifted 1 of the previous crossover as the start marker
                        mask := sub(crossoverPosLeading1, 1)

                        // update for this crossover, (and will be used as start for next crossover)
                        crossoverPosLeading1 := mul(1, exp(2, crossoverPos))
                        mask := xor(mask,
                                    sub(crossoverPosLeading1, 1)
                        )

                        // Now add the parent data to the child genotype
                        // E.g.
                        // Mask:         00000000000001111111111111111110000000000000000000000000000000000000000000000000000000000....
                        // Parent:       10010111001000110101011111001010001011100000000000010011000001000100000001011101111000111....
                        // Child (pre):  00000000000000000000000000000001111110100101111111000011001010000000101010100000110110110....
                        // Child (post): 00000000000000110101011111001011111110100101111111000011001010000000101010100000110110110....

                        // To do this, we run: child_post = child_pre | (mask & father)
                        result := or(result, and(mask, fatherSrc))

                        // Swap father and mother, next crossover will take a string from the other.
                        let temp := fatherSrc
                        fatherSrc := motherSrc
                        motherSrc := temp
                    }

                    // We still have a left-over part that was not copied yet
                    // E.g., we have something like:
                    // Father: |            xxxxxxxxxxxxxxxxxxx          xxxxxxxxxxxxxxxxxxxxxxxx            ....
                    // Mother: |############                   xxxxxxxxxx                        xxxxxxxxxxxx....
                    // Child:  |            xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx....
                    // The ############ still needs to be applied to the child, also,
                    //  this can be done cheaper than in the loop above,
                    //  as we don't have to swap anything for the next crossover or something.

                    // At this point we have to assume 4 crossovers ran,
                    //  and that we only have 127 - 1 - (4 * 7) = 98 bits of randomness left.
                    // We stopped at the bit after the crossoverPos index, see "x":
                    // 000000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.....
                    // now create a leading 1 at crossoverPos like:
                    // 000000001000000000000000000000000000000000000000000000000000000000000000000.....
                    // Sub 1, get the mask for what we had.
                    // 000000000111111111111111111111111111111111111111111111111111111111111111111.....
                    // Invert, and we have the final mask:
                    // 111111111000000000000000000000000000000000000000000000000000000000000000000.....
                    mask := not(sub(crossoverPosLeading1, 1))
                    // Apply it to the result
                    result := or(result, and(mask, fatherSrc))

                    // Random mutations
                    // =====================================================

                    // random mutations
                    // Put rng source in scratchpad 0
                    mstore(0x0, rngSrc)
                    // And some arbitrary padding in scratchpad 1,
                    //  used to create different hashes based on input size changes
                    mstore(0x20, 0x434f4c4c454354205045504553204f4e2043525950544f50455045532e494f21)
                    // Hash it for a universally random bitstring.
                    // Then reduce the number of 1s by AND-ing it with other *different* hashes.
                    // Each bit in mutations has a probability of 0.5^5 = 0.03125 = 3.125% to be a 1
                    let mutations := and(
                            and(
                                and(keccak256(0, 32), keccak256(1, 33)),
                                and(keccak256(2, 34), keccak256(3, 35))
                            ),
                            keccak256(0, 36)
                    )

                    result := xor(result, mutations)

                }
            }


            {

                // Get 1 bit of pseudo randomness that will
                //  determine if side #1 will come from the left, or right side.
                // Either 0 or 1, shift it by 5 bits to get either 0x0 or 0x20, cheaper later on.
                let relativeFatherSideLoc := mul(and(hash, 0x1), 0x20) // shift by 5 bits = mul by 2^5=32 (0x20)
                // Either 0 or 1, shift it by 5 bits to get either 0x0 or 0x20, cheaper later on.
                let relativeMotherSideLoc := mul(and(hash, 0x2), 0x10) // already shifted by 1, mul by 2^4=16 (0x10)

                // Now remove the used 2 bits from the hash, 254 bits remaining now.
                hash := div(hash, 4)

                // Process the side, load the relevant parent data that will be used.
                mstore(memOffset, processSide(
                    mload(add(father, relativeFatherSideLoc)),
                    mload(add(mother, relativeMotherSideLoc)),
                    hash
                ))

                // The other side will be the opposite index: 1 -> 0, 0 -> 1
                // Apply it to the location,
                //  which is either 0x20 (For index 1) or 0x0 for index 0.
                relativeFatherSideLoc := xor(relativeFatherSideLoc, 0x20)
                relativeMotherSideLoc := xor(relativeMotherSideLoc, 0x20)

                mstore(0x0, seed)
                // Second argument will be inverse,
                //  resulting in a different second hash.
                mstore(0x20, not(timestamp))

                // Now create another hash, for the other side
                hash := keccak256(0, 64)

                // Process the other side
                mstore(add(memOffset, 0x20), processSide(
                    mload(add(father, relativeFatherSideLoc)),
                    mload(add(mother, relativeMotherSideLoc)),
                    hash
                ))

            }

        }

        // Sample input:
        // ["0xAAABBBBBBBBCCCCCCCCAAAAAAAAABBBBBBBBBBCCCCCCCCCAABBBBBBBCCCCCCCC","0x4444444455555555555555556666666666666644444444455555555555666666"]
        //
        // ["0x1111111111112222222223333311111111122222223333333331111112222222","0x7777788888888888999999999999977777777777788888888888999999997777"]

        // Expected results (or similar, depends on the seed):
        // 0xAAABBBBBBBBCCCCCCCCAAAAAAAAABBBBBBBBBBCCCCCCCCCAABBBBBBBCCCCCCCC < Father side A
        // 0x4444444455555555555555556666666666666644444444455555555555666666 < Father side B

        // 0x1111111111112222222223333311111111122222223333333331111112222222 < Mother side A
        // 0x7777788888888888999999999999977777777777788888888888999999997777 < Mother side B

        //   xxxxxxxxxxxxxxxxx           xxxxxxxxx                         xx
        // 0xAAABBBBBBBBCCCCCD99999999998BBBBBBBBF77778888888888899999999774C < Child side A
        //   xxx                       xxxxxxxxxxx
        // 0x4441111111112222222223333366666666666222223333333331111112222222 < Child side B

        // And then random mutations, for gene pool expansion.
        // Each bit is flipped with a 3.125% chance

        // Example:
        //a2c37edc61dca0ca0b199e098c80fd5a221c2ad03605b4b54332361358745042 < random hash 1
        //c217d04b19a83fe497c1cf6e1e10030e455a0812a6949282feec27d67fe2baa7 < random hash 2
        //2636a55f38bed26d804c63a13628e21b2d701c902ca37b2b0ca94fada3821364 < random hash 3
        //86bb023a85e2da50ac233b946346a53aa070943b0a8e91c56e42ba181729a5f9 < random hash 4
        //5d71456a1288ab30ddd4c955384d42e66a09d424bd7743791e3eab8e09aa13f1 < random hash 5
        //0000000800800000000000000000000200000000000000000000020000000000 < resulting mutation
        //aaabbbbbbbbcccccd99999999998bbbbbbbbf77778888888888899999999774c < original
        //aaabbbb3bb3cccccd99999999998bbb9bbbbf7777888888888889b999999774c < mutated (= original XOR mutation)
    }

    // Generates (psuedo) random Pepe DNA
    function randomDNA(uint256 seed) internal pure returns (uint256[2] memOffset) {

        // solhint-disable-next-line no-inline-assembly
        assembly {
            // allocate output
            // 1) get the pointer to our memory
            memOffset := mload(0x40)
            // 2) Change the free-memory pointer to keep our memory
            //     (we will only use 64 bytes: 2 values of 256 bits)
            mstore(0x40, add(memOffset, 64))

            // Load the seed into 1st scratchpad memory slot.
            // adjacent to the additional value (used to create two distinct hashes)
            mstore(0x0, seed)

            // In second scratchpad slot:
            // The additional value can be any word, as long as the caller uses
            //  it (second hash needs to be different)
            mstore(0x20, 0x434f4c4c454354205045504553204f4e2043525950544f50455045532e494f21)


            // // Create first element pointer of array
            // mstore(memOffset, add(memOffset, 64)) // pointer 1
            // mstore(add(memOffset, 32), add(memOffset, 96)) // pointer 2

            // control block to auto-pop the hash.
            {
                // L * N * 2 * 4 = 4 * 2 * 2 * 4 = 64 bytes, 2x 256 bit hash

                // Sha3 is cheaper than sha256, make use of it
                let hash := keccak256(0, 64)

                // Store first array value
                mstore(memOffset, hash)

                // Now hash again, but only 32 bytes of input,
                //  to ignore make the input different than the previous call,
                hash := keccak256(0, 32)
                mstore(add(memOffset, 32), hash)

            }

        }
    }

}

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  event OwnershipRenounced(address indexed previousOwner);
  event OwnershipTransferred(
    address indexed previousOwner,
    address indexed newOwner
  );


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  constructor() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to relinquish control of the contract.
   * @notice Renouncing to ownership will leave the contract without an owner.
   * It will not be possible to call the functions with the `onlyOwner`
   * modifier anymore.
   */
  function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(owner);
    owner = address(0);
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function transferOwnership(address _newOwner) public onlyOwner {
    _transferOwnership(_newOwner);
  }

  /**
   * @dev Transfers control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function _transferOwnership(address _newOwner) internal {
    require(_newOwner != address(0));
    emit OwnershipTransferred(owner, _newOwner);
    owner = _newOwner;
  }
}

// File: contracts/Usernames.sol

// solhint-disable-next-line
pragma solidity ^0.4.19;


contract Usernames {

    mapping(address => bytes32) public addressToUser;
    mapping(bytes32 => address) public userToAddress;

    event UserNamed(address indexed user, bytes32 indexed username);

    /**
     * Claim a username. Frees up a previously used one
     * @param _username to claim
     */
    function claimUsername(bytes32 _username) external {
        require(userToAddress[_username] == address(0));// Username must be free

        if (addressToUser[msg.sender] != bytes32(0)) { // If user already has username free it up
            userToAddress[addressToUser[msg.sender]] = address(0);
        }

        //all is well assign username
        addressToUser[msg.sender] = _username;
        userToAddress[_username] = msg.sender;

        emit UserNamed(msg.sender, _username);

    }

}

// File: contracts/Beneficiary.sol

// solhint-disable-next-line
pragma solidity ^0.4.24;



/** @title Beneficiary */
contract Beneficiary is Ownable {
    address public beneficiary;

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

    /**
     * @dev Change the beneficiary address
     * @param _beneficiary Address of the new beneficiary
     */
    function setBeneficiary(address _beneficiary) public onlyOwner {
        beneficiary = _beneficiary;
    }
}

// File: contracts/Affiliate.sol

// solhint-disable-next-line
pragma solidity ^0.4.25;



/** @title Affiliate */
contract Affiliate is Ownable {
    mapping(address => bool) public canSetAffiliate;
    mapping(address => address) public userToAffiliate;

    /** @dev Allows an address to set the affiliate address for a user
      * @param _setter The address that should be allowed
      */
    function setAffiliateSetter(address _setter) public onlyOwner {
        canSetAffiliate[_setter] = true;
    }

    /**
     * @dev Set the affiliate of a user
     * @param _user user to set affiliate for
     * @param _affiliate address to set
     */
    function setAffiliate(address _user, address _affiliate) public {
        require(canSetAffiliate[msg.sender]);
        if (userToAffiliate[_user] == address(0)) {
            userToAffiliate[_user] = _affiliate;
        }
    }

}

// File: contracts/interfaces/ERC721.sol

contract ERC721 {
    function implementsERC721() public pure returns (bool);
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) public view returns (address owner);
    function approve(address _to, uint256 _tokenId) public;
    function transferFrom(address _from, address _to, uint256 _tokenId) public returns (bool) ;
    function transfer(address _to, uint256 _tokenId) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    // Optional
    // function name() public view returns (string name);
    // function symbol() public view returns (string symbol);
    // function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 tokenId);
    // function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}

// File: contracts/interfaces/PepeInterface.sol

contract PepeInterface is ERC721{
    function cozyTime(uint256 _mother, uint256 _father, address _pepeReceiver) public returns (bool);
    function getCozyAgain(uint256 _pepeId) public view returns(uint64);
}

// File: contracts/AuctionBase.sol

// solhint-disable-next-line
pragma solidity ^0.4.24;





/** @title AuctionBase */
contract AuctionBase is Beneficiary {
    mapping(uint256 => PepeAuction) public auctions;//maps pepes to auctions
    PepeInterface public pepeContract;
    Affiliate public affiliateContract;
    uint256 public fee = 37500; //in 1 10000th of a percent so 3.75% at the start
    uint256 public constant FEE_DIVIDER = 1000000; //Perhaps needs better name?

    struct PepeAuction {
        address seller;
        uint256 pepeId;
        uint64 auctionBegin;
        uint64 auctionEnd;
        uint256 beginPrice;
        uint256 endPrice;
    }

    event AuctionWon(uint256 indexed pepe, address indexed winner, address indexed seller);
    event AuctionStarted(uint256 indexed pepe, address indexed seller);
    event AuctionFinalized(uint256 indexed pepe, address indexed seller);

    constructor(address _pepeContract, address _affiliateContract) public {
        pepeContract = PepeInterface(_pepeContract);
        affiliateContract = Affiliate(_affiliateContract);
    }

    /**
     * @dev Return a pepe from a auction that has passed
     * @param  _pepeId the id of the pepe to save
     */
    function savePepe(uint256 _pepeId) external {
        // solhint-disable-next-line not-rely-on-time
        require(auctions[_pepeId].auctionEnd < now);//auction must have ended
        require(pepeContract.transfer(auctions[_pepeId].seller, _pepeId));//transfer pepe back to seller

        emit AuctionFinalized(_pepeId, auctions[_pepeId].seller);

        delete auctions[_pepeId];//delete auction
    }

    /**
     * @dev change the fee on pepe sales. Can only be lowerred
     * @param _fee The new fee to set. Must be lower than current fee
     */
    function changeFee(uint256 _fee) external onlyOwner {
        require(_fee < fee);//fee can not be raised
        fee = _fee;
    }

    /**
     * @dev Start a auction
     * @param  _pepeId Pepe to sell
     * @param  _beginPrice Price at which the auction starts
     * @param  _endPrice Ending price of the auction
     * @param  _duration How long the auction should take
     */
    function startAuction(uint256 _pepeId, uint256 _beginPrice, uint256 _endPrice, uint64 _duration) public {
        require(pepeContract.transferFrom(msg.sender, address(this), _pepeId));
        // solhint-disable-next-line not-rely-on-time
        require(now > auctions[_pepeId].auctionEnd);//can only start new auction if no other is active

        PepeAuction memory auction;

        auction.seller = msg.sender;
        auction.pepeId = _pepeId;
        // solhint-disable-next-line not-rely-on-time
        auction.auctionBegin = uint64(now);
        // solhint-disable-next-line not-rely-on-time
        auction.auctionEnd = uint64(now) + _duration;
        require(auction.auctionEnd > auction.auctionBegin);
        auction.beginPrice = _beginPrice;
        auction.endPrice = _endPrice;

        auctions[_pepeId] = auction;

        emit AuctionStarted(_pepeId, msg.sender);
    }

    /**
     * @dev directly start a auction from the PepeBase contract
     * @param  _pepeId Pepe to put on auction
     * @param  _beginPrice Price at which the auction starts
     * @param  _endPrice Ending price of the auction
     * @param  _duration How long the auction should take
     * @param  _seller The address selling the pepe
     */
    // solhint-disable-next-line max-line-length
    function startAuctionDirect(uint256 _pepeId, uint256 _beginPrice, uint256 _endPrice, uint64 _duration, address _seller) public {
        require(msg.sender == address(pepeContract)); //can only be called by pepeContract
        //solhint-disable-next-line not-rely-on-time
        require(now > auctions[_pepeId].auctionEnd);//can only start new auction if no other is active

        PepeAuction memory auction;

        auction.seller = _seller;
        auction.pepeId = _pepeId;
        // solhint-disable-next-line not-rely-on-time
        auction.auctionBegin = uint64(now);
        // solhint-disable-next-line not-rely-on-time
        auction.auctionEnd = uint64(now) + _duration;
        require(auction.auctionEnd > auction.auctionBegin);
        auction.beginPrice = _beginPrice;
        auction.endPrice = _endPrice;

        auctions[_pepeId] = auction;

        emit AuctionStarted(_pepeId, _seller);
    }

  /**
   * @dev Calculate the current price of a auction
   * @param  _pepeId the pepeID to calculate the current price for
   * @return currentBid the current price for the auction
   */
    function calculateBid(uint256 _pepeId) public view returns(uint256 currentBid) {
        PepeAuction storage auction = auctions[_pepeId];
        // solhint-disable-next-line not-rely-on-time
        uint256 timePassed = now - auctions[_pepeId].auctionBegin;

        // If auction ended return auction end price.
        // solhint-disable-next-line not-rely-on-time
        if (now >= auction.auctionEnd) {
            return auction.endPrice;
        } else {
            // Can be negative
            int256 priceDifference = int256(auction.endPrice) - int256(auction.beginPrice);
            // Always positive
            int256 duration = int256(auction.auctionEnd) - int256(auction.auctionBegin);

            // As already proven in practice by CryptoKitties:
            //  timePassed -> 64 bits at most
            //  priceDifference -> 128 bits at most
            //  timePassed * priceDifference -> 64 + 128 bits at most
            int256 priceChange = priceDifference * int256(timePassed) / duration;

            // Will be positive, both operands are less than 256 bits
            int256 price = int256(auction.beginPrice) + priceChange;

            return uint256(price);
        }
    }

  /**
   * @dev collect the fees from the auction
   */
    function getFees() public {
        beneficiary.transfer(address(this).balance);
    }


}

// File: contracts/CozyTimeAuction.sol

// solhint-disable-next-line
pragma solidity ^0.4.24;



/** @title CozyTimeAuction */
contract CozyTimeAuction is AuctionBase {
    // solhint-disable-next-line
    constructor (address _pepeContract, address _affiliateContract) AuctionBase(_pepeContract, _affiliateContract) public {

    }

    /**
     * @dev Start an auction
     * @param  _pepeId The id of the pepe to start the auction for
     * @param  _beginPrice Start price of the auction
     * @param  _endPrice End price of the auction
     * @param  _duration How long the auction should take
     */
    function startAuction(uint256 _pepeId, uint256 _beginPrice, uint256 _endPrice, uint64 _duration) public {
        // solhint-disable-next-line not-rely-on-time
        require(pepeContract.getCozyAgain(_pepeId) <= now);//need to have this extra check
        super.startAuction(_pepeId, _beginPrice, _endPrice, _duration);
    }

    /**
     * @dev Start a auction direclty from the PepeBase smartcontract
     * @param  _pepeId The id of the pepe to start the auction for
     * @param  _beginPrice Start price of the auction
     * @param  _endPrice End price of the auction
     * @param  _duration How long the auction should take
     * @param  _seller The address of the seller
     */
    // solhint-disable-next-line max-line-length
    function startAuctionDirect(uint256 _pepeId, uint256 _beginPrice, uint256 _endPrice, uint64 _duration, address _seller) public {
        // solhint-disable-next-line not-rely-on-time
        require(pepeContract.getCozyAgain(_pepeId) <= now);//need to have this extra check
        super.startAuctionDirect(_pepeId, _beginPrice, _endPrice, _duration, _seller);
    }

    /**
     * @dev Buy cozy right from the auction
     * @param  _pepeId Pepe to cozy with
     * @param  _cozyCandidate the pepe to cozy with
     * @param  _candidateAsFather Is the _cozyCandidate father?
     * @param  _pepeReceiver address receiving the pepe after cozy time
     */
    // solhint-disable-next-line max-line-length
    function buyCozy(uint256 _pepeId, uint256 _cozyCandidate, bool _candidateAsFather, address _pepeReceiver) public payable {
        require(address(pepeContract) == msg.sender); //caller needs to be the PepeBase contract

        PepeAuction storage auction = auctions[_pepeId];
        // solhint-disable-next-line not-rely-on-time
        require(now < auction.auctionEnd);// auction must be still going

        uint256 price = calculateBid(_pepeId);
        require(msg.value >= price);//must send enough ether
        uint256 totalFee = price * fee / FEE_DIVIDER; //safe math needed?

        //Send ETH to seller
        auction.seller.transfer(price - totalFee);
        //send ETH to beneficiary

        address affiliate = affiliateContract.userToAffiliate(_pepeReceiver);

        //solhint-disable-next-line
        if (affiliate != address(0) && affiliate.send(totalFee / 2)) { //if user has affiliate
            //nothing just to suppress warning
        }

        //actual cozytiming
        if (_candidateAsFather) {
            if (!pepeContract.cozyTime(auction.pepeId, _cozyCandidate, _pepeReceiver)) {
                revert();
            }
        } else {
          // Swap around the two pepes, they have no set gender, the user decides what they are.
            if (!pepeContract.cozyTime(_cozyCandidate, auction.pepeId, _pepeReceiver)) {
                revert();
            }
        }

        //Send pepe to seller of auction
        if (!pepeContract.transfer(auction.seller, _pepeId)) {
            revert(); //can't complete transfer if this fails
        }

        if (msg.value > price) { //return ether send to much
            _pepeReceiver.transfer(msg.value - price);
        }

        emit AuctionWon(_pepeId, _pepeReceiver, auction.seller);//emit event

        delete auctions[_pepeId];//deletes auction
    }

    /**
     * @dev Buy cozytime and pass along affiliate
     * @param  _pepeId Pepe to cozy with
     * @param  _cozyCandidate the pepe to cozy with
     * @param  _candidateAsFather Is the _cozyCandidate father?
     * @param  _pepeReceiver address receiving the pepe after cozy time
     * @param  _affiliate Affiliate address to set
     */
    //solhint-disable-next-line max-line-length
    function buyCozyAffiliated(uint256 _pepeId, uint256 _cozyCandidate, bool _candidateAsFather, address _pepeReceiver, address _affiliate) public payable {
        affiliateContract.setAffiliate(_pepeReceiver, _affiliate);
        buyCozy(_pepeId, _cozyCandidate, _candidateAsFather, _pepeReceiver);
    }
}

// File: contracts/Haltable.sol

// solhint-disable-next-line
pragma solidity ^0.4.24;



contract Haltable is Ownable {
    uint256 public haltTime; //when the contract was halted
    bool public halted;//is the contract halted?
    uint256 public haltDuration;
    uint256 public maxHaltDuration = 8 weeks;//how long the contract can be halted

    modifier stopWhenHalted {
        require(!halted);
        _;
    }

    modifier onlyWhenHalted {
        require(halted);
        _;
    }

    /**
     * @dev Halt the contract for a set time smaller than maxHaltDuration
     * @param  _duration Duration how long the contract should be halted. Must be smaller than maxHaltDuration
     */
    function halt(uint256 _duration) public onlyOwner {
        require(haltTime == 0); //cannot halt if it was halted before
        require(_duration <= maxHaltDuration);//cannot halt for longer than maxHaltDuration
        haltDuration = _duration;
        halted = true;
        // solhint-disable-next-line not-rely-on-time
        haltTime = now;
    }

    /**
     * @dev Unhalt the contract. Can only be called by the owner or when the haltTime has passed
     */
    function unhalt() public {
        // solhint-disable-next-line
        require(now > haltTime + haltDuration || msg.sender == owner);//unhalting is only possible when haltTime has passed or the owner unhalts
        halted = false;
    }

}

// File: openzeppelin-solidity/contracts/math/SafeMath.sol

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
    // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    // uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return a / b;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
    c = a + b;
    assert(c >= a);
    return c;
  }
}

// File: contracts/interfaces/ERC721TokenReceiver.sol

/// @dev Note: the ERC-165 identifier for this interface is 0xf0b9e5ba
interface ERC721TokenReceiver {
    /// @notice Handle the receipt of an NFT
    /// @dev The ERC721 smart contract calls this function on the recipient
    ///  after a `transfer`. This function MAY throw to revert and reject the
    ///  transfer. This function MUST use 50,000 gas or less. Return of other
    ///  than the magic value MUST result in the transaction being reverted.
    ///  Note: the contract address is always the message sender.
    /// @param _from The sending address
    /// @param _tokenId The NFT identifier which is being transfered
    /// @param data Additional data with no specified format
    /// @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
    ///  unless throwing
	function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4);
}

// File: contracts/PepeBase.sol

// solhint-disable-next-line
pragma solidity ^0.4.24;

// solhint-disable func-order










contract PepeBase is Genetic, Ownable, Usernames, Haltable {

    uint32[15] public cozyCoolDowns = [ //determined by generation / 2
        uint32(1 minutes),
        uint32(2 minutes),
        uint32(5 minutes),
        uint32(15 minutes),
        uint32(30 minutes),
        uint32(45 minutes),
        uint32(1 hours),
        uint32(2 hours),
        uint32(4 hours),
        uint32(8 hours),
        uint32(16 hours),
        uint32(1 days),
        uint32(2 days),
        uint32(4 days),
        uint32(7 days)
    ];

    struct Pepe {
        address master; //The master of the pepe
        uint256[2] genotype; //all genes stored here
        uint64 canCozyAgain; //time when pepe can have nice time again
        uint64 generation; //what generation?
        uint64 father; //father of this pepe
        uint64 mother; //mommy of this pepe
        uint8 coolDownIndex;
    }

    mapping(uint256 => bytes32) public pepeNames;

    //stores all pepes
    Pepe[] public pepes;

    bool public implementsERC721 = true; //signal erc721 support

    // solhint-disable-next-line const-name-snakecase
    string public constant name = "Crypto Pepe";
    // solhint-disable-next-line const-name-snakecase
    string public constant symbol = "CPEP";

    mapping(address => uint256[]) private wallets;
    mapping(address => uint256) public balances; //amounts of pepes per address
    mapping(uint256 => address) public approved; //pepe index to address approved to transfer
    mapping(address => mapping(address => bool)) public approvedForAll;

    uint256 public zeroGenPepes; //how many zero gen pepes are mined
    uint256 public constant MAX_PREMINE = 100;//how many pepes can be premined
    uint256 public constant MAX_ZERO_GEN_PEPES = 1100; //max number of zero gen pepes
    address public miner; //address of the miner contract

    modifier onlyPepeMaster(uint256 _pepeId) {
        require(pepes[_pepeId].master == msg.sender);
        _;
    }

    modifier onlyAllowed(uint256 _tokenId) {
        // solhint-disable-next-line max-line-length
        require(msg.sender == pepes[_tokenId].master || msg.sender == approved[_tokenId] || approvedForAll[pepes[_tokenId].master][msg.sender]); //check if msg.sender is allowed
        _;
    }

    event PepeBorn(uint256 indexed mother, uint256 indexed father, uint256 indexed pepeId);
    event PepeNamed(uint256 indexed pepeId);

    constructor() public {

        Pepe memory pepe0 = Pepe({
            master: 0x0,
            genotype: [uint256(0), uint256(0)],
            canCozyAgain: 0,
            father: 0,
            mother: 0,
            generation: 0,
            coolDownIndex: 0
        });

        pepes.push(pepe0);
    }

    /**
     * @dev Internal function that creates a new pepe
     * @param  _genoType DNA of the new pepe
     * @param  _mother The ID of the mother
     * @param  _father The ID of the father
     * @param  _generation The generation of the new Pepe
     * @param  _master The owner of this new Pepe
     * @return The ID of the newly generated Pepe
     */
    // solhint-disable-next-line max-line-length
    function _newPepe(uint256[2] _genoType, uint64 _mother, uint64 _father, uint64 _generation, address _master) internal returns (uint256 pepeId) {
        uint8 tempCoolDownIndex;

        tempCoolDownIndex = uint8(_generation / 2);

        if (_generation > 28) {
            tempCoolDownIndex = 14;
        }

        Pepe memory _pepe = Pepe({
            master: _master, //The master of the pepe
            genotype: _genoType, //all genes stored here
            canCozyAgain: 0, //time when pepe can have nice time again
            father: _father, //father of this pepe
            mother: _mother, //mommy of this pepe
            generation: _generation, //what generation?
            coolDownIndex: tempCoolDownIndex
        });

        if (_generation == 0) {
            zeroGenPepes += 1; //count zero gen pepes
        }

        //push returns the new length, use it to get a new unique id
        pepeId = pepes.push(_pepe) - 1;

        //add it to the wallet of the master of the new pepe
        addToWallet(_master, pepeId);

        emit PepeBorn(_mother, _father, pepeId);
        emit Transfer(address(0), _master, pepeId);

        return pepeId;
    }

    /**
     * @dev Set the miner contract. Can only be called once
     * @param _miner Address of the miner contract
     */
    function setMiner(address _miner) public onlyOwner {
        require(miner == address(0));//can only be set once
        miner = _miner;
    }

    /**
     * @dev Mine a new Pepe. Can only be called by the miner contract.
     * @param  _seed Seed to be used for the generation of the DNA
     * @param  _receiver Address receiving the newly mined Pepe
     * @return The ID of the newly mined Pepe
     */
    function minePepe(uint256 _seed, address _receiver) public stopWhenHalted returns(uint256) {
        require(msg.sender == miner);//only miner contract can call
        require(zeroGenPepes < MAX_ZERO_GEN_PEPES);

        return _newPepe(randomDNA(_seed), 0, 0, 0, _receiver);
    }

    /**
     * @dev Premine pepes. Can only be called by the owner and is limited to MAX_PREMINE
     * @param  _amount Amount of Pepes to premine
     */
    function pepePremine(uint256 _amount) public onlyOwner stopWhenHalted {
        for (uint i = 0; i < _amount; i++) {
            require(zeroGenPepes <= MAX_PREMINE);//can only generate set amount during premine
            //create a new pepe
            // 1) who's genes are based on hash of the timestamp and the number of pepes
            // 2) who has no mother or father
            // 3) who is generation zero
            // 4) who's master is the manager

            // solhint-disable-next-line
            _newPepe(randomDNA(uint256(keccak256(abi.encodePacked(block.timestamp, pepes.length)))), 0, 0, 0, owner);

        }
    }

    /**
     * @dev CozyTime two Pepes together
     * @param  _mother The mother of the new Pepe
     * @param  _father The father of the new Pepe
     * @param  _pepeReceiver Address receiving the new Pepe
     * @return If it was a success
     */
    function cozyTime(uint256 _mother, uint256 _father, address _pepeReceiver) external stopWhenHalted returns (bool) {
        //cannot cozyTime with itself
        require(_mother != _father);
        //caller has to either be master or approved for mother
        // solhint-disable-next-line max-line-length
        require(pepes[_mother].master == msg.sender || approved[_mother] == msg.sender || approvedForAll[pepes[_mother].master][msg.sender]);
        //caller has to either be master or approved for father
        // solhint-disable-next-line max-line-length
        require(pepes[_father].master == msg.sender || approved[_father] == msg.sender || approvedForAll[pepes[_father].master][msg.sender]);
        //require both parents to be ready for cozytime
        // solhint-disable-next-line not-rely-on-time
        require(now > pepes[_mother].canCozyAgain && now > pepes[_father].canCozyAgain);
        //require both mother parents not to be father
        require(pepes[_mother].mother != _father && pepes[_mother].father != _father);
        //require both father parents not to be mother
        require(pepes[_father].mother != _mother && pepes[_father].father != _mother);

        Pepe storage father = pepes[_father];
        Pepe storage mother = pepes[_mother];


        approved[_father] = address(0);
        approved[_mother] = address(0);

        uint256[2] memory newGenotype = breed(father.genotype, mother.genotype, pepes.length);

        uint64 newGeneration;

        newGeneration = mother.generation + 1;
        if (newGeneration < father.generation + 1) { //if father generation is bigger
            newGeneration = father.generation + 1;
        }

        _handleCoolDown(_mother);
        _handleCoolDown(_father);

        //sets pepe birth when mother is done
        // solhint-disable-next-line max-line-length
        pepes[_newPepe(newGenotype, uint64(_mother), uint64(_father), newGeneration, _pepeReceiver)].canCozyAgain = mother.canCozyAgain; //_pepeReceiver becomes the master of the pepe

        return true;
    }

    /**
     * @dev Internal function to increase the coolDownIndex
     * @param _pepeId The id of the Pepe to update the coolDown of
     */
    function _handleCoolDown(uint256 _pepeId) internal {
        Pepe storage tempPep = pepes[_pepeId];

        // solhint-disable-next-line not-rely-on-time
        tempPep.canCozyAgain = uint64(now + cozyCoolDowns[tempPep.coolDownIndex]);

        if (tempPep.coolDownIndex < 14) {// after every cozy time pepe gets slower
            tempPep.coolDownIndex++;
        }

    }

    /**
     * @dev Set the name of a Pepe. Can only be set once
     * @param _pepeId ID of the pepe to name
     * @param _name The name to assign
     */
    function setPepeName(uint256 _pepeId, bytes32 _name) public stopWhenHalted onlyPepeMaster(_pepeId) returns(bool) {
        require(pepeNames[_pepeId] == 0x0000000000000000000000000000000000000000000000000000000000000000);
        pepeNames[_pepeId] = _name;
        emit PepeNamed(_pepeId);
        return true;
    }

    /**
     * @dev Transfer a Pepe to the auction contract and auction it
     * @param  _pepeId ID of the Pepe to auction
     * @param  _auction Auction contract address
     * @param  _beginPrice Price the auction starts at
     * @param  _endPrice Price the auction ends at
     * @param  _duration How long the auction should run
     */
    // solhint-disable-next-line max-line-length
    function transferAndAuction(uint256 _pepeId, address _auction, uint256 _beginPrice, uint256 _endPrice, uint64 _duration) public stopWhenHalted onlyPepeMaster(_pepeId) {
        _transfer(msg.sender, _auction, _pepeId);//transfer pepe to auction
        AuctionBase auction = AuctionBase(_auction);

        auction.startAuctionDirect(_pepeId, _beginPrice, _endPrice, _duration, msg.sender);
    }

    /**
     * @dev Approve and buy. Used to buy cozyTime in one call
     * @param  _pepeId Pepe to cozy with
     * @param  _auction Address of the auction contract
     * @param  _cozyCandidate Pepe to approve and cozy with
     * @param  _candidateAsFather Use the candidate as father or not
     */
    // solhint-disable-next-line max-line-length
    function approveAndBuy(uint256 _pepeId, address _auction, uint256 _cozyCandidate, bool _candidateAsFather) public stopWhenHalted payable onlyPepeMaster(_cozyCandidate) {
        approved[_cozyCandidate] = _auction;
        // solhint-disable-next-line max-line-length
        CozyTimeAuction(_auction).buyCozy.value(msg.value)(_pepeId, _cozyCandidate, _candidateAsFather, msg.sender); //breeding resets approval
    }

    /**
     * @dev The same as above only pass an extra parameter
     * @param  _pepeId Pepe to cozy with
     * @param  _auction Address of the auction contract
     * @param  _cozyCandidate Pepe to approve and cozy with
     * @param  _candidateAsFather Use the candidate as father or not
     * @param  _affiliate Address to set as affiliate
     */
    // solhint-disable-next-line max-line-length
    function approveAndBuyAffiliated(uint256 _pepeId, address _auction, uint256 _cozyCandidate, bool _candidateAsFather, address _affiliate) public stopWhenHalted payable onlyPepeMaster(_cozyCandidate) {
        approved[_cozyCandidate] = _auction;
        // solhint-disable-next-line max-line-length
        CozyTimeAuction(_auction).buyCozyAffiliated.value(msg.value)(_pepeId, _cozyCandidate, _candidateAsFather, msg.sender, _affiliate); //breeding resets approval
    }

    /**
     * @dev get Pepe information
     * @param  _pepeId ID of the Pepe to get information of
     * @return master
     * @return genotype
     * @return canCozyAgain
     * @return generation
     * @return father
     * @return mother
     * @return pepeName
     * @return coolDownIndex
     */
    // solhint-disable-next-line max-line-length
    function getPepe(uint256 _pepeId) public view returns(address master, uint256[2] genotype, uint64 canCozyAgain, uint64 generation, uint256 father, uint256 mother, bytes32 pepeName, uint8 coolDownIndex) {
        Pepe storage tempPep = pepes[_pepeId];

        master = tempPep.master;
        genotype = tempPep.genotype;
        canCozyAgain = tempPep.canCozyAgain;
        generation = tempPep.generation;
        father = tempPep.father;
        mother = tempPep.mother;
        pepeName = pepeNames[_pepeId];
        coolDownIndex = tempPep.coolDownIndex;
    }

    /**
     * @dev Get the time when a pepe can cozy again
     * @param  _pepeId ID of the pepe
     * @return Time when the pepe can cozy again
     */
    function getCozyAgain(uint256 _pepeId) public view returns(uint64) {
        return pepes[_pepeId].canCozyAgain;
    }

    /**
     *  ERC721 Compatibility
     *
     */
    event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

    /**
     * @dev Get the total number of Pepes
     * @return total Returns the total number of pepes
     */
    function totalSupply() public view returns(uint256 total) {
        total = pepes.length - balances[address(0)];
        return total;
    }

    /**
     * @dev Get the number of pepes owned by an address
     * @param  _owner Address to get the balance from
     * @return balance The number of pepes
     */
    function balanceOf(address _owner) external view returns (uint256 balance) {
        balance = balances[_owner];
    }

    /**
     * @dev Get the owner of a Pepe
     * @param  _tokenId the token to get the owner of
     * @return _owner the owner of the pepe
     */
    function ownerOf(uint256 _tokenId) external view returns (address _owner) {
        _owner = pepes[_tokenId].master;
    }

    /**
     * @dev Get the id of an token by its index
     * @param _owner The address to look up the tokens of
     * @param _index Index to look at
     * @return tokenId the ID of the token of the owner at the specified index
     */
    function tokenOfOwnerByIndex(address _owner, uint256 _index) public constant returns (uint256 tokenId) {
        //The index must be smaller than the balance,
        // to guarantee that there is no leftover token returned.
        require(_index < balances[_owner]);

        return wallets[_owner][_index];
    }

    /**
     * @dev Private method that ads a token to the wallet
     * @param _owner Address of the owner
     * @param _tokenId Pepe ID to add
     */
    function addToWallet(address _owner, uint256 _tokenId) private {
        uint256[] storage wallet = wallets[_owner];
        uint256 balance = balances[_owner];
        if (balance < wallet.length) {
            wallet[balance] = _tokenId;
        } else {
            wallet.push(_tokenId);
        }
        //increase owner balance
        //overflow is not likely to happen(need very large amount of pepes)
        balances[_owner] += 1;
    }

    /**
     * @dev Remove a token from a address's wallet
     * @param _owner Address of the owner
     * @param _tokenId Token to remove from the wallet
     */
    function removeFromWallet(address _owner, uint256 _tokenId) private {
        uint256[] storage wallet = wallets[_owner];
        uint256 i = 0;
        // solhint-disable-next-line no-empty-blocks
        for (; wallet[i] != _tokenId; i++) {
            // not the pepe we are looking for
        }
        if (wallet[i] == _tokenId) {
            //found it!
            uint256 last = balances[_owner] - 1;
            if (last > 0) {
                //move the last item to this spot, the last will become inaccessible
                wallet[i] = wallet[last];
            }
            //else: no last item to move, the balance is 0, making everything inaccessible.

            //only decrease balance if _tokenId was in the wallet
            balances[_owner] -= 1;
        }
    }

    /**
     * @dev Internal transfer function
     * @param _from Address sending the token
     * @param _to Address to token is send to
     * @param _tokenId ID of the token to send
     */
    function _transfer(address _from, address _to, uint256 _tokenId) internal {
        pepes[_tokenId].master = _to;
        approved[_tokenId] = address(0);//reset approved of pepe on every transfer

        //remove the token from the _from wallet
        removeFromWallet(_from, _tokenId);

        //add the token to the _to wallet
        addToWallet(_to, _tokenId);

        emit Transfer(_from, _to, _tokenId);
    }

    /**
     * @dev transfer a token. Can only be called by the owner of the token
     * @param  _to Addres to send the token to
     * @param  _tokenId ID of the token to send
     */
    // solhint-disable-next-line no-simple-event-func-name
    function transfer(address _to, uint256 _tokenId) public stopWhenHalted
        onlyPepeMaster(_tokenId) //check if msg.sender is the master of this pepe
        returns(bool)
    {
        _transfer(msg.sender, _to, _tokenId);//after master modifier invoke internal transfer
        return true;
    }

    /**
     * @dev Approve a address to send a token
     * @param _to Address to approve
     * @param _tokenId Token to set approval for
     */
    function approve(address _to, uint256 _tokenId) external stopWhenHalted
        onlyPepeMaster(_tokenId)
    {
        approved[_tokenId] = _to;
        emit Approval(msg.sender, _to, _tokenId);
    }

    /**
     * @dev Approve or revoke approval an address for al tokens of a user
     * @param _operator Address to (un)approve
     * @param _approved Approving or revoking indicator
     */
    function setApprovalForAll(address _operator, bool _approved) external stopWhenHalted {
        if (_approved) {
            approvedForAll[msg.sender][_operator] = true;
        } else {
            approvedForAll[msg.sender][_operator] = false;
        }
        emit ApprovalForAll(msg.sender, _operator, _approved);
    }

    /**
     * @dev Get approved address for a token
     * @param _tokenId Token ID to get the approved address for
     * @return The address that is approved for this token
     */
    function getApproved(uint256 _tokenId) external view returns (address) {
        return approved[_tokenId];
    }

    /**
     * @dev Get if an operator is approved for all tokens of that owner
     * @param _owner Owner to check the approval for
     * @param _operator Operator to check approval for
     * @return Boolean indicating if the operator is approved for that owner
     */
    function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
        return approvedForAll[_owner][_operator];
    }

    /**
     * @dev Function to signal support for an interface
     * @param interfaceID the ID of the interface to check for
     * @return Boolean indicating support
     */
    function supportsInterface(bytes4 interfaceID) external pure returns (bool) {
        if (interfaceID == 0x80ac58cd || interfaceID == 0x01ffc9a7) { //TODO: add more interfaces the contract supports
            return true;
        }
        return false;
    }

    /**
     * @dev Safe transferFrom function
     * @param _from Address currently owning the token
     * @param _to Address to send token to
     * @param _tokenId ID of the token to send
     */
    function safeTransferFrom(address _from, address _to, uint256 _tokenId) external stopWhenHalted {
        _safeTransferFromInternal(_from, _to, _tokenId, "");
    }

    /**
     * @dev Safe transferFrom function with aditional data attribute
     * @param _from Address currently owning the token
     * @param _to Address to send token to
     * @param _tokenId ID of the token to send
     * @param _data Data to pass along call
     */
    // solhint-disable-next-line max-line-length
    function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) external stopWhenHalted {
        _safeTransferFromInternal(_from, _to, _tokenId, _data);
    }

    /**
     * @dev Internal Safe transferFrom function with aditional data attribute
     * @param _from Address currently owning the token
     * @param _to Address to send token to
     * @param _tokenId ID of the token to send
     * @param _data Data to pass along call
     */
    // solhint-disable-next-line max-line-length
    function _safeTransferFromInternal(address _from, address _to, uint256 _tokenId, bytes _data) internal onlyAllowed(_tokenId) {
        require(pepes[_tokenId].master == _from);//check if from is current owner
        require(_to != address(0));//throw on zero address

        _transfer(_from, _to, _tokenId); //transfer token

        if (isContract(_to)) { //check if is contract
            // solhint-disable-next-line max-line-length
            require(ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, _data) == bytes4(keccak256("onERC721Received(address,uint256,bytes)")));
        }
    }

    /**
     * @dev TransferFrom function
     * @param _from Address currently owning the token
     * @param _to Address to send token to
     * @param _tokenId ID of the token to send
     * @return If it was successful
     */
    // solhint-disable-next-line max-line-length
    function transferFrom(address _from, address _to, uint256 _tokenId) public stopWhenHalted onlyAllowed(_tokenId) returns(bool) {
        require(pepes[_tokenId].master == _from);//check if _from is really the master.
        require(_to != address(0));
        _transfer(_from, _to, _tokenId);//handles event, balances and approval reset;
        return true;
    }

    /**
     * @dev Utility method to check if an address is a contract
     * @param _address Address to check
     * @return Boolean indicating if the address is a contract
     */
    function isContract(address _address) internal view returns (bool) {
        uint size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(_address) }
        return size > 0;
    }

}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[{"name":"interfaceID","type":"bytes4"}],"name":"supportsInterface","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"approve","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"approvedForAll","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"implementsERC721","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_seed","type":"uint256"},{"name":"_receiver","type":"address"}],"name":"minePepe","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"total","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_amount","type":"uint256"}],"name":"pepePremine","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"zeroGenPepes","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_pepeId","type":"uint256"},{"name":"_name","type":"bytes32"}],"name":"setPepeName","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balances","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"pepeNames","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_pepeId","type":"uint256"}],"name":"getPepe","outputs":[{"name":"master","type":"address"},{"name":"genotype","type":"uint256[2]"},{"name":"canCozyAgain","type":"uint64"},{"name":"generation","type":"uint64"},{"name":"father","type":"uint256"},{"name":"mother","type":"uint256"},{"name":"pepeName","type":"bytes32"},{"name":"coolDownIndex","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"name":"tokenId","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"miner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"R","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxHaltDuration","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_pepeId","type":"uint256"}],"name":"getCozyAgain","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"name":"_owner","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"userToAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_username","type":"bytes32"}],"name":"claimUsername","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"MAX_ZERO_GEN_PEPES","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"approved","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_pepeId","type":"uint256"},{"name":"_auction","type":"address"},{"name":"_beginPrice","type":"uint256"},{"name":"_endPrice","type":"uint256"},{"name":"_duration","type":"uint64"}],"name":"transferAndAuction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_miner","type":"address"}],"name":"setMiner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_pepeId","type":"uint256"},{"name":"_auction","type":"address"},{"name":"_cozyCandidate","type":"uint256"},{"name":"_candidateAsFather","type":"bool"},{"name":"_affiliate","type":"address"}],"name":"approveAndBuyAffiliated","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"_operator","type":"address"},{"name":"_approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"haltDuration","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"},{"name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"halted","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_mother","type":"uint256"},{"name":"_father","type":"uint256"},{"name":"_pepeReceiver","type":"address"}],"name":"cozyTime","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unhalt","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"cozyCoolDowns","outputs":[{"name":"","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_pepeId","type":"uint256"},{"name":"_auction","type":"address"},{"name":"_cozyCandidate","type":"uint256"},{"name":"_candidateAsFather","type":"bool"}],"name":"approveAndBuy","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"addressToUser","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"haltTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"MAX_PREMINE","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"pepes","outputs":[{"name":"master","type":"address"},{"name":"canCozyAgain","type":"uint64"},{"name":"generation","type":"uint64"},{"name":"father","type":"uint64"},{"name":"mother","type":"uint64"},{"name":"coolDownIndex","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_duration","type":"uint256"}],"name":"halt","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"mother","type":"uint256"},{"indexed":true,"name":"father","type":"uint256"},{"indexed":true,"name":"pepeId","type":"uint256"}],"name":"PepeBorn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"pepeId","type":"uint256"}],"name":"PepeNamed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_approved","type":"address"},{"indexed":false,"name":"_tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":true,"name":"_tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_operator","type":"address"},{"indexed":false,"name":"_approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"user","type":"address"},{"indexed":true,"name":"username","type":"bytes32"}],"name":"UserNamed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"}],"name":"OwnershipRenounced","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

6249d400600655610260604052603c6080908152607860a05261012c60c05261038460e05261070861010052610a8c61012052610e1061014052611c2061016052613840610180526170806101a05261e1006101c052620151806101e0526202a30061020052620546006102205262093a80610240526200008590600790600f62000261565b50600b805460ff19166001179055348015620000a057600080fd5b50620000ab62000304565b506000805433600160a060020a03199182161782556040805160e0810182528381528151808301835284815260208082018690528201908152918101849052606081018490526080810184905260a0810184905260c08101849052600a8054600181018083559190955281517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a860059096029586018054909516600160a060020a03909116178455915190939192849290916200018d917fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a9019060026200034b565b5060408201516003820180546060850151608086015160a087015167ffffffffffffffff1990931667ffffffffffffffff95861617604060020a608060020a031916680100000000000000009286169290920291909117608060020a60c060020a0319167001000000000000000000000000000000009185169190910217600160c060020a03167801000000000000000000000000000000000000000000000000939091169290920291909117905560c0909101516004909101805460ff191660ff90921691909117905550620003e99050565b600283019183908215620002f25791602002820160005b83821115620002be57835183826101000a81548163ffffffff021916908363ffffffff160217905550926020019260040160208160030104928301926001030262000278565b8015620002f05782816101000a81549063ffffffff0219169055600401602081600301049283019260010302620002be565b505b50620003009291506200038a565b5090565b604080516101008101909152600081526020810162000322620003b1565b815260006020820181905260408201819052606082018190526080820181905260a09091015290565b82600281019282156200037c579160200282015b828111156200037c5782518255916020019190600101906200035f565b5062000300929150620003cc565b620003ae91905b808211156200030057805463ffffffff1916815560010162000391565b90565b60408051808201825290600290829080388339509192915050565b620003ae91905b80821115620003005760008155600101620003d3565b6128bd80620003f96000396000f3006080604052600436106102505763ffffffff7c010000000000000000000000000000000000000000000000000000000060003504166301ffc9a7811461025557806306fdde031461028b578063081812fc14610315578063095ea7b3146103495780630b1714fd1461036f5780631051db341461039657806313aa48bf146103ab57806318160ddd146103e15780631977bd68146103f657806321a764301461040e578063228dff131461042357806323b872dd1461043e57806327e235e3146104685780632df1f1b6146104895780632e1a9ffe146104a15780632f745c591461053d578063349dc3291461056157806342842e0e146105765780634980e1be146105a0578063583c2e7b146105cb57806362bc63c4146105e05780636352211e146106155780636c88beeb1461062d57806370a0823114610645578063715018a61461066657806371e68cad1461067b57806373a01b75146106935780637d4061e6146106a857806382cf2116146106c05780638da5cb5b146106f757806395d89b411461070c5780639742ca46146107215780639d18e40514610742578063a22cb46514610769578063a9059cbb1461078f578063b3ecf7a6146107b3578063b88d4fde146107c8578063b9b8af0b14610801578063c29338cf14610816578063cb3e64fd1461083d578063d346658b14610852578063e23a778514610883578063e985e9c5146108a2578063edf53886146108c9578063ee66875a146108ea578063f2fde38b146108ff578063f73bda7214610920578063fb139a2114610935578063fb1fad501461099b575b600080fd5b34801561026157600080fd5b50610277600160e060020a0319600435166109b3565b604080519115158252519081900360200190f35b34801561029757600080fd5b506102a0610a2c565b6040805160208082528351818301528351919283929083019185019080838360005b838110156102da5781810151838201526020016102c2565b50505050905090810190601f1680156103075780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b34801561032157600080fd5b5061032d600435610a63565b60408051600160a060020a039092168252519081900360200190f35b34801561035557600080fd5b5061036d600160a060020a0360043516602435610a7e565b005b34801561037b57600080fd5b50610277600160a060020a0360043581169060243516610b2b565b3480156103a257600080fd5b50610277610b4b565b3480156103b757600080fd5b506103cf600435600160a060020a0360243516610b54565b60408051918252519081900360200190f35b3480156103ed57600080fd5b506103cf610bac565b34801561040257600080fd5b5061036d600435610bdf565b34801561041a57600080fd5b506103cf610cdb565b34801561042f57600080fd5b50610277600435602435610ce1565b34801561044a57600080fd5b50610277600160a060020a0360043581169060243516604435610d85565b34801561047457600080fd5b506103cf600160a060020a0360043516610eaa565b34801561049557600080fd5b506103cf600435610ebc565b3480156104ad57600080fd5b506104b9600435610ece565b60408051600160a060020a038a168152906020820190899080838360005b838110156104ef5781810151838201526020016104d7565b50505067ffffffffffffffff9a8b169390910192835250509590961660208601526040808601949094526060850192909252608084015260ff1660a0830152519081900360c0019350915050f35b34801561054957600080fd5b506103cf600160a060020a0360043516602435610fb1565b34801561056d57600080fd5b5061032d61100c565b34801561058257600080fd5b5061036d600160a060020a036004358116906024351660443561101b565b3480156105ac57600080fd5b506105b561104c565b6040805160ff9092168252519081900360200190f35b3480156105d757600080fd5b506103cf611051565b3480156105ec57600080fd5b506105f8600435611057565b6040805167ffffffffffffffff9092168252519081900360200190f35b34801561062157600080fd5b5061032d60043561108c565b34801561063957600080fd5b5061032d6004356110bd565b34801561065157600080fd5b506103cf600160a060020a03600435166110d8565b34801561067257600080fd5b5061036d6110f3565b34801561068757600080fd5b5061036d600435611152565b34801561069f57600080fd5b506103cf61120e565b3480156106b457600080fd5b5061032d600435611214565b3480156106cc57600080fd5b5061036d600435600160a060020a036024351660443560643567ffffffffffffffff6084351661122f565b34801561070357600080fd5b5061032d61132c565b34801561071857600080fd5b506102a061133b565b34801561072d57600080fd5b5061036d600160a060020a0360043516611372565b61036d600435600160a060020a0360243581169060443590606435151590608435166113c1565b34801561077557600080fd5b5061036d600160a060020a036004351660243515156114a5565b34801561079b57600080fd5b50610277600160a060020a0360043516602435611560565b3480156107bf57600080fd5b506103cf6115be565b3480156107d457600080fd5b5061036d600160a060020a03600480358216916024803590911691604435916064359081019101356115c4565b34801561080d57600080fd5b50610277611617565b34801561082257600080fd5b50610277600435602435600160a060020a0360443516611620565b34801561084957600080fd5b5061036d611af9565b34801561085e57600080fd5b5061086a600435611b2e565b6040805163ffffffff9092168252519081900360200190f35b61036d600435600160a060020a03602435166044356064351515611b5b565b3480156108ae57600080fd5b50610277600160a060020a0360043581169060243516611c55565b3480156108d557600080fd5b506103cf600160a060020a0360043516611c83565b3480156108f657600080fd5b506103cf611c95565b34801561090b57600080fd5b5061036d600160a060020a0360043516611c9b565b34801561092c57600080fd5b506103cf611cbe565b34801561094157600080fd5b5061094d600435611cc3565b60408051600160a060020a03909716875267ffffffffffffffff9586166020880152938516868501529184166060860152909216608084015260ff90911660a0830152519081900360c00190f35b3480156109a757600080fd5b5061036d600435611d40565b60007f80ac58cd00000000000000000000000000000000000000000000000000000000600160e060020a031983161480610a1657507f01ffc9a700000000000000000000000000000000000000000000000000000000600160e060020a03198316145b15610a2357506001610a27565b5060005b919050565b60408051808201909152600b81527f43727970746f2050657065000000000000000000000000000000000000000000602082015281565b6000908152600e6020526040902054600160a060020a031690565b60045460ff1615610a8e57600080fd5b600a80548291339183908110610aa057fe5b6000918252602090912060059091020154600160a060020a031614610ac457600080fd5b6000828152600e60209081526040918290208054600160a060020a031916600160a060020a03871690811790915582518581529251909233927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92592918290030190a3505050565b600f60209081526000928352604080842090915290825290205460ff1681565b600b5460ff1681565b60045460009060ff1615610b6757600080fd5b601154600160a060020a03163314610b7e57600080fd5b60105461044c11610b8e57600080fd5b610ba5610b9a84611d89565b600080600086611dd6565b9392505050565b60008052600d6020527f81955a0a11e65eac625c29e8882660bae4e165a75d72780094acae8ece9a29ee54600a54035b90565b60008054600160a060020a03163314610bf757600080fd5b60045460ff1615610c0757600080fd5b5060005b81811015610cd75760105460641015610c2357600080fd5b610cce610cb842600a8054905060405160200180838152602001828152602001925050506040516020818303038152906040526040518082805190602001908083835b60208310610c855780518252601f199092019160209182019101610c66565b5181516020939093036101000a600019018019909116921691909117905260405192018290039091209250611d89915050565b6000805481908190600160a060020a0316611dd6565b50600101610c0b565b5050565b60105481565b60045460009060ff1615610cf457600080fd5b600a80548491339183908110610d0657fe5b6000918252602090912060059091020154600160a060020a031614610d2a57600080fd5b60008481526009602052604090205415610d4357600080fd5b6000848152600960205260408082208590555185917f5a8858069902ead8e61944d06d7de6818a0dd09b668447431ac1501baa5e8ef891a25060019392505050565b60045460009060ff1615610d9857600080fd5b81600a81815481101515610da857fe5b6000918252602090912060059091020154600160a060020a0316331480610de557506000818152600e6020526040902054600160a060020a031633145b80610e375750600f6000600a83815481101515610dfe57fe5b60009182526020808320600590920290910154600160a060020a03168352828101939093526040918201812033825290925290205460ff165b1515610e4257600080fd5b84600160a060020a0316600a84815481101515610e5b57fe5b6000918252602090912060059091020154600160a060020a031614610e7f57600080fd5b600160a060020a0384161515610e9457600080fd5b610e9f85858561206c565b506001949350505050565b600d6020526000908152604090205481565b60096020526000908152604090205481565b6000610ed86127d9565b6000806000806000806000600a8a815481101515610ef257fe5b6000918252602090912060059091020180546040805180820191829052600160a060020a039092169b5091925090600183019060029082845b815481526020019060010190808311610f2b57505050600384015460009d8e5260096020526040909d20546004909401549b9d929c67ffffffffffffffff8082169d68010000000000000000830482169d50700100000000000000000000000000000000830482169c5060c060020a9092041699509397505060ff909216945092505050565b600160a060020a0382166000908152600d60205260408120548210610fd557600080fd5b600160a060020a0383166000908152600c60205260409020805483908110610ff957fe5b9060005260206000200154905092915050565b601154600160a060020a031681565b60045460ff161561102b57600080fd5b6110478383836020604051908101604052806000815250612117565b505050565b600581565b60065481565b6000600a8281548110151561106857fe5b600091825260209091206005909102016003015467ffffffffffffffff1692915050565b6000600a8281548110151561109d57fe5b6000918252602090912060059091020154600160a060020a031692915050565b600260205260009081526040902054600160a060020a031681565b600160a060020a03166000908152600d602052604090205490565b600054600160a060020a0316331461110a57600080fd5b60008054604051600160a060020a03909116917ff8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c6482091a260008054600160a060020a0319169055565b600081815260026020526040902054600160a060020a03161561117457600080fd5b33600090815260016020526040902054156111b457336000908152600160209081526040808320548352600290915290208054600160a060020a03191690555b33600081815260016020908152604080832085905584835260029091528082208054600160a060020a03191684179055518392917f43c1ac38b68f3a24742fba8f0826c9fcf340d41f123872fa3175164d117e25af91a350565b61044c81565b600e60205260009081526040902054600160a060020a031681565b60045460009060ff161561124257600080fd5b600a8054879133918390811061125457fe5b6000918252602090912060059091020154600160a060020a03161461127857600080fd5b61128333878961206c565b604080517fd024cd0200000000000000000000000000000000000000000000000000000000815260048101899052602481018790526044810186905267ffffffffffffffff851660648201523360848201529051879350600160a060020a0384169163d024cd029160a480830192600092919082900301818387803b15801561130b57600080fd5b505af115801561131f573d6000803e3d6000fd5b5050505050505050505050565b600054600160a060020a031681565b60408051808201909152600481527f4350455000000000000000000000000000000000000000000000000000000000602082015281565b600054600160a060020a0316331461138957600080fd5b601154600160a060020a03161561139f57600080fd5b60118054600160a060020a031916600160a060020a0392909216919091179055565b60045460ff16156113d157600080fd5b600a805484913391839081106113e357fe5b6000918252602090912060059091020154600160a060020a03161461140757600080fd5b6000848152600e60205260408082208054600160a060020a031916600160a060020a0389811691821790925582517fa6da467c000000000000000000000000000000000000000000000000000000008152600481018b905260248101899052871515604482015233606482015291861660848301529151919263a6da467c92349260a480820193929182900301818588803b15801561130b57600080fd5b60045460ff16156114b557600080fd5b80156114ee57336000908152600f60209081526040808320600160a060020a03861684529091529020805460ff1916600117905561151a565b336000908152600f60209081526040808320600160a060020a03861684529091529020805460ff191690555b6040805182151581529051600160a060020a0384169133917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c319181900360200190a35050565b60045460009060ff161561157357600080fd5b600a8054839133918390811061158557fe5b6000918252602090912060059091020154600160a060020a0316146115a957600080fd5b6115b433858561206c565b5060019392505050565b60055481565b60045460ff16156115d457600080fd5b61161085858585858080601f01602080910402602001604051908101604052809392919081815260200183838082843750612117945050505050565b5050505050565b60045460ff1681565b600080600061162d6127d9565b60045460009060ff161561164057600080fd5b8787141561164d57600080fd5b600a80543391908a90811061165e57fe5b6000918252602090912060059091020154600160a060020a0316148061169a57506000888152600e6020526040902054600160a060020a031633145b806116ec5750600f6000600a8a8154811015156116b357fe5b60009182526020808320600590920290910154600160a060020a03168352828101939093526040918201812033825290925290205460ff165b15156116f757600080fd5b600a80543391908990811061170857fe5b6000918252602090912060059091020154600160a060020a0316148061174457506000878152600e6020526040902054600160a060020a031633145b806117965750600f6000600a8981548110151561175d57fe5b60009182526020808320600590920290910154600160a060020a03168352828101939093526040918201812033825290925290205460ff165b15156117a157600080fd5b600a8054899081106117af57fe5b600091825260209091206003600590920201015467ffffffffffffffff16421180156118055750600a8054889081106117e457fe5b600091825260209091206003600590920201015467ffffffffffffffff1642115b151561181057600080fd5b86600a8981548110151561182057fe5b600091825260209091206005909102016003015460c060020a900467ffffffffffffffff1614801590611893575086600a8981548110151561185e57fe5b6000918252602090912060059091020160030154700100000000000000000000000000000000900467ffffffffffffffff1614155b151561189e57600080fd5b87600a888154811015156118ae57fe5b600091825260209091206005909102016003015460c060020a900467ffffffffffffffff1614801590611921575087600a888154811015156118ec57fe5b6000918252602090912060059091020160030154700100000000000000000000000000000000900467ffffffffffffffff1614155b151561192c57600080fd5b600a80548890811061193a57fe5b90600052602060002090600502019350600a8881548110151561195957fe5b600091825260208083208a8452600e90915260408084208054600160a060020a03199081169091558c8552938190208054909416909355825180840193849052600592909202019450611a0291600187019060029082845b8154815260200190600101908083116119b1575050604080518082019182905293506001890192506002915082845b8154815260200190600101908083116119e0575050600a5492506123cd915050565b91508260030160089054906101000a900467ffffffffffffffff1660010190508360030160089054906101000a900467ffffffffffffffff1660010167ffffffffffffffff168167ffffffffffffffff161015611a795750600383015468010000000000000000900467ffffffffffffffff166001015b611a828861254e565b611a8b8761254e565b600383015467ffffffffffffffff16600a611aa9848b8b868c611dd6565b81548110611ab357fe5b906000526020600020906005020160030160006101000a81548167ffffffffffffffff021916908367ffffffffffffffff16021790555060019450505050509392505050565b60055460035401421180611b175750600054600160a060020a031633145b1515611b2257600080fd5b6004805460ff19169055565b600781600f8110611b3b57fe5b60089182820401919006600402915054906101000a900463ffffffff1681565b60045460ff1615611b6b57600080fd5b600a80548391339183908110611b7d57fe5b6000918252602090912060059091020154600160a060020a031614611ba157600080fd5b6000838152600e60205260408082208054600160a060020a031916600160a060020a03881690811790915581517fd3ce71df000000000000000000000000000000000000000000000000000000008152600481018990526024810187905285151560448201523360648201529151909263d3ce71df9234926084808301939282900301818588803b158015611c3557600080fd5b505af1158015611c49573d6000803e3d6000fd5b50505050505050505050565b600160a060020a039182166000908152600f6020908152604080832093909416825291909152205460ff1690565b60016020526000908152604090205481565b60035481565b600054600160a060020a03163314611cb257600080fd5b611cbb816125f5565b50565b606481565b600a805482908110611cd157fe5b6000918252602090912060059091020180546003820154600490920154600160a060020a03909116925067ffffffffffffffff80831692680100000000000000008104821692700100000000000000000000000000000000820483169260c060020a9092049091169060ff1686565b600054600160a060020a03163314611d5757600080fd5b60035415611d6457600080fd5b600654811115611d7357600080fd5b6005556004805460ff1916600117905542600355565b611d916127d9565b5060408051808201825260009283527f434f4c4c454354205045504553204f4e2043525950544f50455045532e494f2160209081529183208152918190209082015290565b600080611de16127f4565b600267ffffffffffffffff8616049150601c8567ffffffffffffffff161115611e0957600e91505b506040805160e081018252600160a060020a03851681526020810189905260009181019190915267ffffffffffffffff85811660608301819052878216608084015290881660a083015260ff831660c08301521515611e6c576010805460010190555b600a8054600180820180845560009390935283517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a860059093029283018054600160a060020a031916600160a060020a0390921691909117815560208501519193928592611efe917fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a901906002612839565b5060408201516003820180546060850151608086015160a087015167ffffffffffffffff1990931667ffffffffffffffff958616176fffffffffffffffff0000000000000000191668010000000000000000928616929092029190911777ffffffffffffffff000000000000000000000000000000001916700100000000000000000000000000000000918516919091021777ffffffffffffffffffffffffffffffffffffffffffffffff1660c060020a939091169290920291909117905560c0909101516004909101805460ff191660ff909216919091179055039250611fe68484612665565b828667ffffffffffffffff168867ffffffffffffffff167f160403841b73fe58236181ab476e17f2836a5b4aa8a570d9f1baf4b6ed61a38a60405160405180910390a46040518390600160a060020a038616906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4505095945050505050565b81600a8281548110151561207c57fe5b6000918252602080832060059092029091018054600160a060020a0394909416600160a060020a0319948516179055838252600e905260409020805490911690556120c783826126eb565b6120d18282612665565b8082600160a060020a031684600160a060020a03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050565b81600a8181548110151561212757fe5b6000918252602090912060059091020154600160a060020a031633148061216457506000818152600e6020526040902054600160a060020a031633145b806121b65750600f6000600a8381548110151561217d57fe5b60009182526020808320600590920290910154600160a060020a03168352828101939093526040918201812033825290925290205460ff165b15156121c157600080fd5b84600160a060020a0316600a848154811015156121da57fe5b6000918252602090912060059091020154600160a060020a0316146121fe57600080fd5b600160a060020a038416151561221357600080fd5b61221e85858561206c565b612227846127d1565b156116105760405180807f6f6e455243373231526563656976656428616464726573732c75696e7432353681526020017f2c62797465732900000000000000000000000000000000000000000000000000815250602701905060405180910390207bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191684600160a060020a031663f0b9e5ba8786866040518463ffffffff167c01000000000000000000000000000000000000000000000000000000000281526004018084600160a060020a0316600160a060020a0316815260200183815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561233f578181015183820152602001612327565b50505050905090810190601f16801561236c5780820380516001836020036101000a031916815260200191505b50945050505050602060405180830381600087803b15801561238d57600080fd5b505af11580156123a1573d6000803e3d6000fd5b505050506040513d60208110156123b757600080fd5b5051600160e060020a0319161461161057600080fd5b6123d56127d9565b604051905060408101604052816000524260205260406000206123fe565b60029190910a900490565b6124eb565b6000600184161515612413579091905b61241e6001856123f3565b9350600080607f86166124326007886123f3565b96508060015b600484106101008310161561248657959695600019908101600283900a9182011880891696909617959450607f8916925061247460078a6123f3565b98508282019150600184019350612438565b6001810319945086851686179550886000527f434f4c4c454354205045504553204f4e2043525950544f50455045532e494f21602052602460002060236003206022600220166021600120602060002016161680871896505050505050509392505050565b6020600182160260106002831602600483049250612510838289015184890151612403565b84526020821891506020811890508460005242196020526040600020925061253f838289015184890151612403565b60208501525050509392505050565b6000600a8281548110151561255f57fe5b60009182526020909120600590910201600481015490915060079060ff16600f811061258757fe5b60088104919091015460038301805467ffffffffffffffff1916600790931660049081026101000a90920463ffffffff16420167ffffffffffffffff1692909217909155810154600e60ff9091161015610cd757600401805460ff8082166001011660ff1990911617905550565b600160a060020a038116151561260a57600080fd5b60008054604051600160a060020a03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a360008054600160a060020a031916600160a060020a0392909216919091179055565b600160a060020a0382166000908152600c60209081526040808320600d9092529091205481548110156126b2578282828154811015156126a157fe5b6000918252602090912001556126c8565b8154600181018355600083815260209020018390555b505050600160a060020a03166000908152600d6020526040902080546001019055565b600160a060020a0382166000908152600c6020526040812090805b83838381548110151561271557fe5b906000526020600020015414151561273257600190910190612706565b83838381548110151561274157fe5b906000526020600020015414156116105750600160a060020a0384166000908152600d602052604081205460001901908111156127ac57828181548110151561278657fe5b9060005260206000200154838381548110151561279f57fe5b6000918252602090912001555b50505050600160a060020a03166000908152600d602052604090208054600019019055565b6000903b1190565b60408051808201825290600290829080388339509192915050565b60408051610100810190915260008152602081016128106127d9565b815260006020820181905260408201819052606082018190526080820181905260a09091015290565b8260028101928215612867579160200282015b8281111561286757825182559160200191906001019061284c565b50612873929150612877565b5090565b610bdc91905b80821115612873576000815560010161287d5600a165627a7a72305820824faa9a1a1c971be5f5b529149a59e462185c5aef8cde729b59ca67cbf5ff420029

Swarm Source

bzzr://824faa9a1a1c971be5f5b529149a59e462185c5aef8cde729b59ca67cbf5ff42
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.