blackhat ethereum runtime bytecode rattle output

rattle.log

<SSA::Function _dispatch hash:0xffffffff ofs:0x0 blocks:[
  <SSA::BasicBlock ofs:0x0 insns:[
    MSTORE(#0x40, #0x60),
    %0 = CALLDATASIZE(),
    %1 = LT(%0, #0x4),
    JUMPI(#0x62, %1),
  ]>,
  <SSA::BasicBlock ofs:0xd insns:[
    %2 = CALLDATALOAD(#0x0),
    %3 = DIV(%2, #0x100000000000000000000000000000000000000000000000000000000),
    %4 = AND(#0xFFFFFFFF, %3),
    %5 = EQ(#0x41C0E1B5, %4),
    METHODCALL(hash:0x41c0e1b5, %5),
  ]>,
  <SSA::BasicBlock ofs:0x41 insns:[
    %6 = EQ(#0xA840DDA9, %4),
    METHODCALL(hash:0xa840dda9, %6),
  ]>,
  <SSA::BasicBlock ofs:0x4c insns:[
    %7 = EQ(#0xB69EF8A8, %4),
    METHODCALL(hash:0xb69ef8a8, %7),
  ]>,
  <SSA::BasicBlock ofs:0x57 insns:[
    %8 = EQ(#0xF8626AF8, %4),
    METHODCALL(hash:0xf8626af8, %8),
  ]>,
  <SSA::BasicBlock ofs:0x62 insns:[
    %9 = CALLVALUE(),
    %a = SLOAD(#0x1),
    %b = ADD(%a, %9),
    SSTORE(#0x1, %b),
    STOP(),
  ]>,
]>





<SSA::Function kill() hash:0x41c0e1b5 ofs:0x74 blocks:[
  <SSA::BasicBlock ofs:0x74 insns:[
    %0 = CALLVALUE(),
    %1 = ISZERO(%0),
    JUMPI(#0x7F, %1),
  ]>,
  <SSA::BasicBlock ofs:0x7b insns:[
    REVERT(#0x0, #0x0),
  ]>,
  <SSA::BasicBlock ofs:0x7f insns:[
    JUMP(#0x126),
  ]>,
  <SSA::BasicBlock ofs:0x126 insns:[
    %2 = SLOAD(#0x0),
    %3 = EXP(#0x100, #0x0),
    %4 = DIV(%2, %3),
    %5 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %4),
    %6 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %5),
    %7 = CALLER(),
    %8 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %7),
    %9 = EQ(%8, %6),
    %a = ISZERO(%9),
    %b = ISZERO(%a),
    JUMPI(#0x181, %b),
  ]>,
  <SSA::BasicBlock ofs:0x17d insns:[
    REVERT(#0x0, #0x0),
  ]>,
  <SSA::BasicBlock ofs:0x181 insns:[
    %c = SLOAD(#0x0),
    %d = EXP(#0x100, #0x0),
    %e = DIV(%c, %d),
    %f = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %e),
    %10 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %f),
    SUICIDE(%10),
  ]>,
]>





<SSA::Function <unknown> hash:0xa840dda9 ofs:0x89 blocks:[
  <SSA::BasicBlock ofs:0x89 insns:[
    JUMP(#0x1BB),
  ]>,
  <SSA::BasicBlock ofs:0x1bb insns:[
    %0 = CALLVALUE(),
    %1 = LT(%0, #0x8AC7230489E80000),
    %2 = ISZERO(%1),
    %3 = ISZERO(%2),
    %4 = ISZERO(%3),
    JUMPI(#0x1D4, %4),
  ]>,
  <SSA::BasicBlock ofs:0x1d0 insns:[
    REVERT(#0x0, #0x0),
  ]>,
  <SSA::BasicBlock ofs:0x1d4 insns:[
    %5 = CALLER(),
    %6 = ADD(#0x0, #0x0),
    %7 = EXP(#0x100, #0x0),
    %8 = SLOAD(%6),
    %9 = MUL(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %7),
    %a = NOT(%9),
    %b = AND(%a, %8),
    %c = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %5),
    %d = MUL(%c, %7),
    %e = OR(%d, %b),
    SSTORE(%6, %e),
    %f = CALLVALUE(),
    %10 = ADD(#0x1, #0x0),
    SSTORE(%10, %f),
    %11 = CALLVALUE(),
    %12 = SLOAD(#0x1),
    %13 = ADD(%12, %11),
    SSTORE(#0x1, %13),
    %14 = TIMESTAMP(),
    MSTORE(#0x0, %14),
    %15 = ADD(#0x20, #0x0),
    MSTORE(%15, #0x2),
    %16 = ADD(#0x20, %15),
    %17 = SHA3(#0x0, %16),
    %18 = ADD(#0x0, #0x0),
    %19 = SLOAD(%18),
    %1a = EXP(#0x100, #0x0),
    %1b = DIV(%19, %1a),
    %1c = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %1b),
    %1d = ADD(#0x0, %17),
    %1e = EXP(#0x100, #0x0),
    %1f = SLOAD(%1d),
    %20 = MUL(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %1e),
    %21 = NOT(%20),
    %22 = AND(%21, %1f),
    %23 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %1c),
    %24 = MUL(%23, %1e),
    %25 = OR(%24, %22),
    SSTORE(%1d, %25),
    %26 = ADD(#0x0, #0x1),
    %27 = SLOAD(%26),
    %28 = ADD(#0x1, %17),
    SSTORE(%28, %27),
    %29 = SLOAD(#0x1),
    %2a = MUL(#0x1, %29),
    %2b = NOT(#0x0),
    %2c = AND(%2b, %2a),
    %2d = CALLVALUE(),
    %2e = MUL(#0x1, %2d),
    %2f = NOT(#0x0),
    %30 = AND(%2f, %2e),
    %31 = CALLER(),
    %32 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %31),
    %33 = MUL(#0x1, %32),
    %34 = NOT(#0x0),
    %35 = AND(%34, %33),
    %36 = TIMESTAMP(),
    %37 = MUL(#0x1, %36),
    %38 = MLOAD(#0x40),
    %39 = NOT(#0x0),
    %3a = AND(%39, %37),
    %3b = NOT(#0x0),
    %3c = AND(%3b, %3a),
    MSTORE(%38, %3c),
    %3d = ADD(#0x20, %38),
    %3e = MLOAD(#0x40),
    %3f = SUB(%3d, %3e),
    LOG3(%3e, %3f, %35, %30, %2c),
    JUMP(#0x91),
  ]>,
  <SSA::BasicBlock ofs:0x91 insns:[
    STOP(),
  ]>,
]>





<SSA::Function balance() hash:0xb69ef8a8 ofs:0x93 blocks:[
  <SSA::BasicBlock ofs:0x93 insns:[
    %0 = CALLVALUE(),
    %1 = ISZERO(%0),
    JUMPI(#0x9E, %1),
  ]>,
  <SSA::BasicBlock ofs:0x9a insns:[
    REVERT(#0x0, #0x0),
  ]>,
  <SSA::BasicBlock ofs:0x9e insns:[
    JUMP(#0x30C),
  ]>,
  <SSA::BasicBlock ofs:0x30c insns:[
    %2 = SLOAD(#0x1),
    JUMP(#0xA6),
  ]>,
  <SSA::BasicBlock ofs:0xa6 insns:[
    %3 = MLOAD(#0x40),
    MSTORE(%3, %2),
    %4 = ADD(#0x20, %3),
    %5 = MLOAD(#0x40),
    %6 = SUB(%4, %5),
    RETURN(%5, %6),
  ]>,
]>





<SSA::Function <unknown> hash:0xf8626af8 ofs:0xbc blocks:[
  <SSA::BasicBlock ofs:0xbc insns:[
    %0 = CALLVALUE(),
    %1 = ISZERO(%0),
    JUMPI(#0xC7, %1),
  ]>,
  <SSA::BasicBlock ofs:0xc3 insns:[
    REVERT(#0x0, #0x0),
  ]>,
  <SSA::BasicBlock ofs:0xc7 insns:[
    %2 = CALLDATALOAD(#0x4),
    %3 = ADD(#0x20, #0x4),
    JUMP(#0x312),
  ]>,
  <SSA::BasicBlock ofs:0x312 insns:[
    MSTORE(#0x20, #0x2),
    MSTORE(#0x0, %2),
    %4 = SHA3(#0x0, #0x40),
    %5 = ADD(#0x0, %4),
    %6 = SLOAD(%5),
    %7 = EXP(#0x100, #0x0),
    %8 = DIV(%6, %7),
    %9 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %8),
    %a = ADD(#0x1, %4),
    %b = SLOAD(%a),
    JUMP(#0xDD),
  ]>,
  <SSA::BasicBlock ofs:0xdd insns:[
    %c = MLOAD(#0x40),
    %d = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %9),
    %e = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %d),
    MSTORE(%c, %e),
    %f = ADD(#0x20, %c),
    MSTORE(%f, %b),
    %10 = ADD(#0x20, %f),
    %11 = MLOAD(#0x40),
    %12 = SUB(%10, %11),
    RETURN(%11, %12),
  ]>,
]>