Online Solidity Decompiler

« Decompile another contract

Address

0x1c29c23f1b40695fd2dca3a9ba3537c8f1fb8fce [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x79c76e1a flush(address)

Internal Methods

func_0075(arg0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 != 0x79c76e1a) { revert(memory[0x00:0x00]); } var var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0073; var var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; func_0075(var2); stop(); } function func_0075(var arg0) { if (msg.sender == storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff) { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = address(this); var var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = 0xa9059cbb; var var2 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; var var3 = var0; var var4 = 0x70a08231; var var5 = temp0 + 0x24; var var6 = 0x20; var var7 = memory[0x40:0x60]; var var8 = temp0 - var7 + 0x24; var var10 = 0x00; var var9 = var7; var var11 = var3; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp1; temp1, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); var6 = !temp1; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x20) { revert(memory[0x00:0x00]); } var temp2 = memory[var3:var3 + 0x20]; var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = (var1 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000; memory[temp3 + 0x04:temp3 + 0x04 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp3 + 0x24:temp3 + 0x24 + 0x20] = temp2; var2 = temp3 + 0x44; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = temp3 - var4 + 0x44; var6 = var4; var7 = var3; var8 = var0; var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp4; temp4, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp4; if (!var3) { return; } var temp5 = returndata.length; memory[0x00:0x00 + temp5] = returndata[0x00:0x00 + temp5]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp6 = returndata.length; memory[0x00:0x00 + temp6] = returndata[0x00:0x00 + temp6]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; memory[temp7 + 0x04:temp7 + 0x04 + 0x20] = 0x20; memory[temp7 + 0x24:temp7 + 0x24 + 0x20] = 0x13; memory[temp7 + 0x44:temp7 + 0x44 + 0x20] = 0x556e617574686f72697a65642063616c6c657200000000000000000000000000; var temp8 = memory[0x40:0x60]; revert(memory[temp8:temp8 + temp7 - temp8 + 0x64]); } } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0040 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0040, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @0032 msg.data[0x00:0x20] } 000D 63 PUSH4 0xffffffff 0012 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0030 60 PUSH1 0x00 0032 35 CALLDATALOAD 0033 04 DIV 0034 16 AND 0035 63 PUSH4 0x79c76e1a 003A 81 DUP2 003B 14 EQ 003C 61 PUSH2 0x0045 003F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0034 stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff } // Block ends with conditional jump to 0x0045, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x79c76e1a label_0040: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x003F, if not msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x79c76e1a // Inputs[1] { @0044 memory[0x00:0x00] } 0040 5B JUMPDEST 0041 60 PUSH1 0x00 0043 80 DUP1 0044 FD *REVERT // Stack delta = +0 // Outputs[1] { @0044 revert(memory[0x00:0x00]); } // Block terminates label_0045: // Incoming jump from 0x003F, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x79c76e1a // Inputs[1] { @0046 msg.value } 0045 5B JUMPDEST 0046 34 CALLVALUE 0047 80 DUP1 0048 15 ISZERO 0049 61 PUSH2 0x0051 004C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0046 stack[0] = msg.value } // Block ends with conditional jump to 0x0051, if !msg.value label_004D: // Incoming jump from 0x004C, if not !msg.value // Inputs[1] { @0050 memory[0x00:0x00] } 004D 60 PUSH1 0x00 004F 80 DUP1 0050 FD *REVERT // Stack delta = +0 // Outputs[1] { @0050 revert(memory[0x00:0x00]); } // Block terminates label_0051: // Incoming jump from 0x004C, if !msg.value // Inputs[1] { @006D msg.data[0x04:0x24] } 0051 5B JUMPDEST 0052 50 POP 0053 61 PUSH2 0x0073 0056 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 006B 60 PUSH1 0x04 006D 35 CALLDATALOAD 006E 16 AND 006F 61 PUSH2 0x0075 0072 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0053 stack[-1] = 0x0073 // @006E stack[0] = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with call to 0x0075, returns to 0x0073 label_0073: // Incoming return from call to 0x0075 at 0x0072 0073 5B JUMPDEST 0074 00 *STOP // Stack delta = +0 // Outputs[1] { @0074 stop(); } // Block terminates label_0075: // Incoming call from 0x0072, returns to 0x0073 // Inputs[2] // { // @0078 storage[0x00] // @008F msg.sender // } 0075 5B JUMPDEST 0076 60 PUSH1 0x00 0078 54 SLOAD 0079 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 008E 16 AND 008F 33 CALLER 0090 14 EQ 0091 61 PUSH2 0x00fb 0094 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fb, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] label_0095: // Incoming jump from 0x0094, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] // Inputs[3] // { // @0098 memory[0x40:0x60] // @00F1 memory[0x40:0x60] // @00FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0095 60 PUSH1 0x40 0097 80 DUP1 0098 51 MLOAD 0099 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 00BA 81 DUP2 00BB 52 MSTORE 00BC 60 PUSH1 0x20 00BE 60 PUSH1 0x04 00C0 82 DUP3 00C1 01 ADD 00C2 52 MSTORE 00C3 60 PUSH1 0x13 00C5 60 PUSH1 0x24 00C7 82 DUP3 00C8 01 ADD 00C9 52 MSTORE 00CA 7F PUSH32 0x556e617574686f72697a65642063616c6c657200000000000000000000000000 00EB 60 PUSH1 0x44 00ED 82 DUP3 00EE 01 ADD 00EF 52 MSTORE 00F0 90 SWAP1 00F1 51 MLOAD 00F2 90 SWAP1 00F3 81 DUP2 00F4 90 SWAP1 00F5 03 SUB 00F6 60 PUSH1 0x64 00F8 01 ADD 00F9 90 SWAP1 00FA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @00BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @00C2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @00C9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @00EF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e617574686f72697a65642063616c6c657200000000000000000000000000 // @00FA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_00FB: // Incoming jump from 0x0094, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] // Inputs[6] // { // @00FF storage[0x00] // @0103 memory[0x40:0x60] // @0127 address(this) // @012E memory[0x40:0x60] // @0145 stack[-1] // @0170 address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 00FB 5B JUMPDEST 00FC 60 PUSH1 0x00 00FE 80 DUP1 00FF 54 SLOAD 0100 60 PUSH1 0x40 0102 80 DUP1 0103 51 MLOAD 0104 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 0125 81 DUP2 0126 52 MSTORE 0127 30 ADDRESS 0128 60 PUSH1 0x04 012A 82 DUP3 012B 01 ADD 012C 52 MSTORE 012D 90 SWAP1 012E 51 MLOAD 012F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0144 80 DUP1 0145 86 DUP7 0146 16 AND 0147 94 SWAP5 0148 63 PUSH4 0xa9059cbb 014D 94 SWAP5 014E 90 SWAP1 014F 91 SWAP2 0150 16 AND 0151 92 SWAP3 0152 85 DUP6 0153 92 SWAP3 0154 63 PUSH4 0x70a08231 0159 92 SWAP3 015A 60 PUSH1 0x24 015C 80 DUP1 015D 84 DUP5 015E 01 ADD 015F 93 SWAP4 0160 60 PUSH1 0x20 0162 93 SWAP4 0163 92 SWAP3 0164 90 SWAP1 0165 83 DUP4 0166 90 SWAP1 0167 03 SUB 0168 90 SWAP1 0169 91 SWAP2 016A 01 ADD 016B 90 SWAP1 016C 82 DUP3 016D 90 SWAP1 016E 87 DUP8 016F 80 DUP1 0170 3B EXTCODESIZE 0171 15 ISZERO 0172 80 DUP1 0173 15 ISZERO 0174 61 PUSH2 0x017c 0177 57 *JUMPI // Stack delta = +13 // Outputs[15] // { // @0126 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @012C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0147 stack[0] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @014D stack[1] = 0xa9059cbb // @0151 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] // @0153 stack[3] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @0159 stack[4] = 0x70a08231 // @015F stack[5] = memory[0x40:0x60] + 0x24 // @0162 stack[6] = 0x20 // @0163 stack[7] = memory[0x40:0x60] // @016B stack[8] = 0x24 + (memory[0x40:0x60] - memory[0x40:0x60]) // @016D stack[9] = memory[0x40:0x60] // @016D stack[10] = 0x00 // @016E stack[11] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @0171 stack[12] = !address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x017c, if !!address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_0178: // Incoming jump from 0x0177, if not !!address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @017B memory[0x00:0x00] } 0178 60 PUSH1 0x00 017A 80 DUP1 017B FD *REVERT // Stack delta = +0 // Outputs[1] { @017B revert(memory[0x00:0x00]); } // Block terminates label_017C: // Incoming jump from 0x0177, if !!address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[9] // { // @017E msg.gas // @017F stack[-5] // @017F stack[-3] // @017F stack[-6] // @017F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @017F stack[-4] // @017F memory[stack[-4]:stack[-4] + stack[-5]] // @017F stack[-2] // @017F stack[-7] // } 017C 5B JUMPDEST 017D 50 POP 017E 5A GAS 017F F1 CALL 0180 15 ISZERO 0181 80 DUP1 0182 15 ISZERO 0183 61 PUSH2 0x0190 0186 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @017F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0180 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0190, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0187: // Incoming jump from 0x0186, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0187 returndata.length // @018B returndata[0x00:0x00 + returndata.length] // @018C returndata.length // @018F memory[0x00:0x00 + returndata.length] // } 0187 3D RETURNDATASIZE 0188 60 PUSH1 0x00 018A 80 DUP1 018B 3E RETURNDATACOPY 018C 3D RETURNDATASIZE 018D 60 PUSH1 0x00 018F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @018B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @018F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0190: // Incoming jump from 0x0186, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0197 memory[0x40:0x60] // @0198 returndata.length // } 0190 5B JUMPDEST 0191 50 POP 0192 50 POP 0193 50 POP 0194 50 POP 0195 60 PUSH1 0x40 0197 51 MLOAD 0198 3D RETURNDATASIZE 0199 60 PUSH1 0x20 019B 81 DUP2 019C 10 LT 019D 15 ISZERO 019E 61 PUSH2 0x01a6 01A1 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0197 stack[-4] = memory[0x40:0x60] // @0198 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x01a6, if !(returndata.length < 0x20) label_01A2: // Incoming jump from 0x01A1, if not !(returndata.length < 0x20) // Inputs[1] { @01A5 memory[0x00:0x00] } 01A2 60 PUSH1 0x00 01A4 80 DUP1 01A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A5 revert(memory[0x00:0x00]); } // Block terminates label_01A6: // Incoming jump from 0x01A1, if !(returndata.length < 0x20) // Inputs[8] // { // @01A8 memory[stack[-2]:stack[-2] + 0x20] // @01A8 stack[-2] // @01AC memory[0x40:0x60] // @01D0 stack[-4] // @01EB stack[-3] // @01FA memory[0x40:0x60] // @020C stack[-5] // @020E address(stack[-5]).code.length // } 01A6 5B JUMPDEST 01A7 50 POP 01A8 51 MLOAD 01A9 60 PUSH1 0x40 01AB 80 DUP1 01AC 51 MLOAD 01AD 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 01CB 63 PUSH4 0xffffffff 01D0 86 DUP7 01D1 16 AND 01D2 02 MUL 01D3 81 DUP2 01D4 52 MSTORE 01D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01EA 90 SWAP1 01EB 93 SWAP4 01EC 16 AND 01ED 60 PUSH1 0x04 01EF 84 DUP5 01F0 01 ADD 01F1 52 MSTORE 01F2 60 PUSH1 0x24 01F4 83 DUP4 01F5 01 ADD 01F6 91 SWAP2 01F7 90 SWAP1 01F8 91 SWAP2 01F9 52 MSTORE 01FA 51 MLOAD 01FB 60 PUSH1 0x44 01FD 80 DUP1 01FE 83 DUP4 01FF 01 ADD 0200 92 SWAP3 0201 60 PUSH1 0x00 0203 92 SWAP3 0204 91 SWAP2 0205 90 SWAP1 0206 82 DUP3 0207 90 SWAP1 0208 03 SUB 0209 01 ADD 020A 81 DUP2 020B 83 DUP4 020C 87 DUP8 020D 80 DUP1 020E 3B EXTCODESIZE 020F 15 ISZERO 0210 80 DUP1 0211 15 ISZERO 0212 61 PUSH2 0x021a 0215 57 *JUMPI // Stack delta = +5 // Outputs[11] // { // @01D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000 // @01F1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @01F9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0200 stack[-3] = memory[0x40:0x60] + 0x44 // @0203 stack[-2] = 0x00 // @0204 stack[-1] = memory[0x40:0x60] // @0209 stack[0] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @020A stack[1] = memory[0x40:0x60] // @020B stack[2] = 0x00 // @020C stack[3] = stack[-5] // @020F stack[4] = !address(stack[-5]).code.length // } // Block ends with conditional jump to 0x021a, if !!address(stack[-5]).code.length label_0216: // Incoming jump from 0x0215, if not !!address(stack[-5]).code.length // Inputs[1] { @0219 memory[0x00:0x00] } 0216 60 PUSH1 0x00 0218 80 DUP1 0219 FD *REVERT // Stack delta = +0 // Outputs[1] { @0219 revert(memory[0x00:0x00]); } // Block terminates label_021A: // Incoming jump from 0x0215, if !!address(stack[-5]).code.length // Inputs[9] // { // @021C msg.gas // @021D stack[-3] // @021D stack[-6] // @021D stack[-5] // @021D memory[stack[-4]:stack[-4] + stack[-5]] // @021D stack[-4] // @021D stack[-2] // @021D address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @021D stack[-7] // } 021A 5B JUMPDEST 021B 50 POP 021C 5A GAS 021D F1 CALL 021E 15 ISZERO 021F 80 DUP1 0220 15 ISZERO 0221 61 PUSH2 0x022e 0224 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @021D memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @021E stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x022e, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0225: // Incoming jump from 0x0224, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0225 returndata.length // @0229 returndata[0x00:0x00 + returndata.length] // @022A returndata.length // @022D memory[0x00:0x00 + returndata.length] // } 0225 3D RETURNDATASIZE 0226 60 PUSH1 0x00 0228 80 DUP1 0229 3E RETURNDATACOPY 022A 3D RETURNDATASIZE 022B 60 PUSH1 0x00 022D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0229 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @022D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_022E: // Incoming jump from 0x0224, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0234 stack[-6] } 022E 5B JUMPDEST 022F 50 POP 0230 50 POP 0231 50 POP 0232 50 POP 0233 50 POP 0234 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] 0235 00 *STOP 0236 A1 LOG1 0237 65 PUSH6 0x627a7a723058 023E 20 SHA3 023F 30 ADDRESS 0240 0B SIGNEXTEND 0241 43 NUMBER 0242 BE BE 0243 F2 CALLCODE 0244 96 SWAP7 0245 FC FC 0246 F4 DELEGATECALL 0247 1F 1F 0248 34 CALLVALUE 0249 22 22 024A 66 PUSH7 0xbed518123eab89 0252 05 SDIV 0253 7E PUSH31 0x6fc9c4fcea47cd754787bf0029
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]