Skip to content

Instantly share code, notes, and snippets.

@hrkrshnn

hrkrshnn/diff.diff

Created July 16, 2020 12:18
Show Gist options
  • Save hrkrshnn/e622364b543d6e26a70266e25e88a48a to your computer and use it in GitHub Desktop.
Save hrkrshnn/e622364b543d6e26a70266e25e88a48a to your computer and use it in GitHub Desktop.
Download ZIP
Raw
diff.diff
diff -u /tmp/abiOptold.yul /tmp/abiOpt.yul
--- /tmp/abiOptold.yul 2020-07-16 17:42:12.321040915 +0530
+++ /tmp/abiOpt.yul 2020-07-16 17:41:26.225218259 +0530
@@ -35,9 +35,9 @@
case 0x19da7652 {
if callvalue() { revert(_2, _2) }
let param, param_1, param_2, param_3 := abi_decode_tuple_t_array$_t_uint256_$30_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(_1, calldatasize())
- let ret_1, ret_2 := fun_f6_120(param, param_1, param_2, param_3)
+ let vloc__114_mpos, vloc__117_mpos := fun_f6_120()
let memPos_1 := allocateMemory(_2)
- return(memPos_1, sub(abi_encode_tuple_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_1, ret_1, ret_2), memPos_1))
+ return(memPos_1, sub(abi_encode_tuple_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_1, vloc__114_mpos, vloc__117_mpos), memPos_1))
}
case 0x3a69a8c8 {
if callvalue() { revert(_2, _2) }
@@ -83,14 +83,14 @@
}
case 0xcd580ff3 {
if callvalue() { revert(_2, _2) }
- let ret_3 := getter_fun_b_6(abi_decode_tuple_t_uint256(_1, calldatasize()))
+ let ret_1 := getter_fun_b_6(abi_decode_tuple_t_uint256(_1, calldatasize()))
let memPos_9 := allocateMemory(_2)
- return(memPos_9, sub(abi_encode_tuple_t_uint256__to_t_uint256__fromStack(memPos_9, ret_3), memPos_9))
+ return(memPos_9, sub(abi_encode_tuple_t_uint256__to_t_uint256__fromStack(memPos_9, ret_1), memPos_9))
}
}
revert(0, 0)
}
- function abi_decode_t_address(offset, end) -> value
+ function abi_decode_t_address(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }
@@ -185,12 +185,12 @@
calldatacopy(add(array, 0x20), add(offset, 0x20), length)
mstore(add(add(array, length), 0x20), 0)
}
- function abi_decode_t_uint16(offset, end) -> value
+ function abi_decode_t_uint16(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, 0xffff))) { revert(0, 0) }
}
- function abi_decode_t_uint32(offset, end) -> value
+ function abi_decode_t_uint32(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, 0xffffffff))) { revert(0, 0) }
@@ -218,7 +218,7 @@
let i := value0
for { } lt(i, length) { i := add(i, 1) }
{
- mstore(dst, abi_decode_t_address(src, dataEnd))
+ mstore(dst, abi_decode_t_address(src))
dst := add(dst, _3)
src := add(src, _3)
}
@@ -229,7 +229,7 @@
let offset_2 := calldataload(add(headStart, 64))
if gt(offset_2, _1) { revert(value2, value2) }
value2 := abi_decode_t_bytes_memory_ptr(add(headStart, offset_2), dataEnd)
- value3 := abi_decode_t_address(add(headStart, 96), dataEnd)
+ value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint16_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
@@ -250,7 +250,7 @@
let i := value2
for { } lt(i, length) { i := add(i, 1) }
{
- mstore(dst, abi_decode_t_uint16(src, dataEnd))
+ mstore(dst, abi_decode_t_uint16(src))
dst := add(dst, _3)
src := add(src, _3)
}
@@ -258,8 +258,8 @@
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd)
- value2 := abi_decode_t_uint16(add(headStart, 64), dataEnd)
- value3 := abi_decode_t_address(add(headStart, 96), dataEnd)
+ value2 := abi_decode_t_uint16(add(headStart, 64))
+ value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint256_$30_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
@@ -283,8 +283,8 @@
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd)
- value2 := abi_decode_t_uint16(add(headStart, 992), dataEnd)
- value3 := abi_decode_t_address(add(headStart, 1024), dataEnd)
+ value2 := abi_decode_t_uint16(add(headStart, 992))
+ value3 := abi_decode_t_address(add(headStart, 1024))
}
function abi_decode_tuple_t_array$_t_uint256_$31_memory_ptrt_array$_t_string_memory_ptr_$20_memory_ptrt_contract$_C_$164t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
@@ -308,8 +308,8 @@
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$20_memory_ptr(add(headStart, offset), dataEnd)
- value2 := abi_decode_t_address(add(headStart, 1024), dataEnd)
- value3 := abi_decode_t_address(add(headStart, 1056), dataEnd)
+ value2 := abi_decode_t_address(add(headStart, 1024))
+ value3 := abi_decode_t_address(add(headStart, 1056))
}
function abi_decode_tuple_t_array$_t_uint256_$32_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint32t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
@@ -332,8 +332,8 @@
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd)
- value2 := abi_decode_t_uint32(add(headStart, 1056), dataEnd)
- value3 := abi_decode_t_address(add(headStart, 1088), dataEnd)
+ value2 := abi_decode_t_uint32(add(headStart, 1056))
+ value3 := abi_decode_t_address(add(headStart, 1088))
}
function abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
@@ -362,8 +362,8 @@
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd)
- value2 := abi_decode_t_uint16(add(headStart, 64), dataEnd)
- value3 := abi_decode_t_address(add(headStart, 96), dataEnd)
+ value2 := abi_decode_t_uint16(add(headStart, 64))
+ value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint32_$dyn_memory_ptrt_array$_t_string_memory_ptr_$12_memory_ptrt_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptrt_address(headStart, dataEnd) -> value0, value1, value2, value3
{
@@ -384,7 +384,7 @@
let i := value2
for { } lt(i, length) { i := add(i, 1) }
{
- mstore(dst, abi_decode_t_uint32(src, dataEnd))
+ mstore(dst, abi_decode_t_uint32(src))
dst := add(dst, _3)
src := add(src, _3)
}
@@ -395,7 +395,7 @@
let offset_2 := calldataload(add(headStart, 64))
if gt(offset_2, _1) { revert(value2, value2) }
value2 := abi_decode_t_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptr(add(headStart, offset_2), dataEnd)
- value3 := abi_decode_t_address(add(headStart, 96), dataEnd)
+ value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0
{
@@ -511,7 +511,7 @@
if gt(length, 0xffffffffffffffff) { revert(size, size) }
size := mul(length, 0x20)
}
- function fun_f6_120(vloc__102_mpos, vloc__105_mpos, vloc, vloc_1) -> vloc__114_mpos, vloc__117_mpos
+ function fun_f6_120() -> vloc__114_mpos, vloc__117_mpos
{
let _1 := 6400
let memPtr := allocateMemory(_1)
Diff finished. Thu Jul 16 17:43:17 2020
Raw
new.yul
Optimized IR:
/*******************************************************
* WARNING *
* Solidity to Yul compilation is still EXPERIMENTAL *
* It can result in LOSS OF FUNDS or worse *
* !USE AT YOUR OWN RISK! *
*******************************************************/
object "C_164" {
code {
{
mstore(64, 128)
if callvalue() { revert(0, 0) }
let _1 := datasize("C_164_deployed")
codecopy(0, dataoffset("C_164_deployed"), _1)
return(0, _1)
}
}
object "C_164_deployed" {
code {
{
mstore(64, 128)
let _1 := 4
if iszero(lt(calldatasize(), _1))
{
let _2 := 0
switch shr(224, calldataload(_2))
case 0x0dbe671f {
if callvalue() { revert(_2, _2) }
abi_decode_tuple_(_1, calldatasize())
let ret := sload(_2)
let memPos := allocateMemory(_2)
return(memPos, sub(abi_encode_tuple_t_uint256__to_t_uint256__fromStack(memPos, ret), memPos))
}
case 0x19da7652 {
if callvalue() { revert(_2, _2) }
let param, param_1, param_2, param_3 := abi_decode_tuple_t_array$_t_uint256_$30_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(_1, calldatasize())
let vloc__114_mpos, vloc__117_mpos := fun_f6_120()
let memPos_1 := allocateMemory(_2)
return(memPos_1, sub(abi_encode_tuple_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_1, vloc__114_mpos, vloc__117_mpos), memPos_1))
}
case 0x3a69a8c8 {
if callvalue() { revert(_2, _2) }
let param_4, param_5, param_6, param_7 := abi_decode_tuple_t_array$_t_uint16_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(_1, calldatasize())
let memPos_2 := allocateMemory(_2)
return(memPos_2, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_2, 96, 96), memPos_2))
}
case 0x40b9ccd0 {
if callvalue() { revert(_2, _2) }
let param_8, param_9, param_10, param_11 := abi_decode_tuple_t_array$_t_uint32_$dyn_memory_ptrt_array$_t_string_memory_ptr_$12_memory_ptrt_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptrt_address(_1, calldatasize())
let memPos_3 := allocateMemory(_2)
return(memPos_3, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_3, 96, 96), memPos_3))
}
case 0x66941981 {
if callvalue() { revert(_2, _2) }
let param_12, param_13, param_14, param_15 := abi_decode_tuple_t_array$_t_address_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_bytes_memory_ptrt_address(_1, calldatasize())
let memPos_4 := allocateMemory(_2)
return(memPos_4, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_4, 96, 96), memPos_4))
}
case 0x8f448bde {
if callvalue() { revert(_2, _2) }
let param_16, param_17, param_18, param_19 := abi_decode_tuple_t_array$_t_uint256_$31_memory_ptrt_array$_t_string_memory_ptr_$20_memory_ptrt_contract$_C_$164t_address(_1, calldatasize())
let memPos_5 := allocateMemory(_2)
return(memPos_5, sub(abi_encode_tuple_t_array$_t_bytes_memory_ptr_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_bytes_memory_ptr_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_5, 96, 96), memPos_5))
}
case 0x931538b4 {
if callvalue() { revert(_2, _2) }
let param_20, param_21, param_22, param_23 := abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(_1, calldatasize())
let memPos_6 := allocateMemory(_2)
return(memPos_6, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_6, 96, 96), memPos_6))
}
case 0x9adbf691 {
if callvalue() { revert(_2, _2) }
pop(abi_decode_tuple_t_uint256(_1, calldatasize()))
let memPos_7 := allocateMemory(_2)
return(memPos_7, sub(abi_encode_tuple_t_uint256__to_t_uint256__fromStack(memPos_7, _2), memPos_7))
}
case 0xc94cc147 {
if callvalue() { revert(_2, _2) }
let param_24, param_25, param_26, param_27 := abi_decode_tuple_t_array$_t_uint256_$32_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint32t_address(_1, calldatasize())
let memPos_8 := allocateMemory(_2)
return(memPos_8, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_8, 96, 96), memPos_8))
}
case 0xcd580ff3 {
if callvalue() { revert(_2, _2) }
let ret_1 := getter_fun_b_6(abi_decode_tuple_t_uint256(_1, calldatasize()))
let memPos_9 := allocateMemory(_2)
return(memPos_9, sub(abi_encode_tuple_t_uint256__to_t_uint256__fromStack(memPos_9, ret_1), memPos_9))
}
}
revert(0, 0)
}
function abi_decode_t_address(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }
}
function abi_decode_t_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
let length := calldataload(offset)
array := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst := array
mstore(array, length)
let _1 := 0x20
dst := add(array, _1)
let src := add(offset, _1)
let i := 0
for { } lt(i, length) { i := add(i, 1) }
{
let _2 := add(offset, calldataload(src))
if iszero(slt(add(_2, 63), end)) { revert(0, 0) }
let _3 := 0x02
let dst_1 := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_3))
let dst_2 := dst_1
let src_1 := add(_2, _1)
let i_1 := 0
for { } lt(i_1, _3) { i_1 := add(i_1, 1) }
{
mstore(dst_1, abi_decode_t_bytes_memory_ptr(add(add(_2, calldataload(src_1)), _1), end))
dst_1 := add(dst_1, _1)
src_1 := add(src_1, _1)
}
mstore(dst, dst_2)
dst := add(dst, _1)
src := add(src, _1)
}
}
function abi_decode_t_array$_t_string_memory_ptr_$12_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
array := allocateMemory(384)
let dst := array
let src := offset
let i := 0
for { } lt(i, 0x0c) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_bytes_memory_ptr(add(offset, calldataload(src)), end))
let _1 := 0x20
dst := add(dst, _1)
src := add(src, _1)
}
}
function abi_decode_t_array$_t_string_memory_ptr_$20_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
array := allocateMemory(640)
let dst := array
let src := offset
let i := 0
for { } lt(i, 0x14) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_bytes_memory_ptr(add(offset, calldataload(src)), end))
let _1 := 0x20
dst := add(dst, _1)
src := add(src, _1)
}
}
function abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
let length := calldataload(offset)
array := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst := array
mstore(array, length)
let _1 := 0x20
dst := add(array, _1)
let src := add(offset, _1)
let i := 0
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_bytes_memory_ptr(add(add(offset, calldataload(src)), _1), end))
dst := add(dst, _1)
src := add(src, _1)
}
}
function abi_decode_t_bytes_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
let length := calldataload(offset)
if gt(length, 0xffffffffffffffff) { revert(array, array) }
array := allocateMemory(add(and(add(length, 0x1f), not(31)), 0x20))
mstore(array, length)
if gt(add(add(offset, length), 0x20), end) { revert(0, 0) }
calldatacopy(add(array, 0x20), add(offset, 0x20), length)
mstore(add(add(array, length), 0x20), 0)
}
function abi_decode_t_uint16(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, 0xffff))) { revert(0, 0) }
}
function abi_decode_t_uint32(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, 0xffffffff))) { revert(0, 0) }
}
function abi_decode_tuple_(headStart, dataEnd)
{
if slt(sub(dataEnd, headStart), 0) { revert(0, 0) }
}
function abi_decode_tuple_t_array$_t_address_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_bytes_memory_ptrt_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 128) { revert(value0, value0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(value0, value0) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value0, value0) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst_1 := dst
mstore(dst, length)
let _3 := 0x20
dst := add(dst, _3)
let src := add(_2, _3)
if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(value0, value0) }
let i := value0
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_address(src))
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value1, value1) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd)
let offset_2 := calldataload(add(headStart, 64))
if gt(offset_2, _1) { revert(value2, value2) }
value2 := abi_decode_t_bytes_memory_ptr(add(headStart, offset_2), dataEnd)
value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint16_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(value2, value2) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst_1 := dst
mstore(dst, length)
let _3 := 0x20
dst := add(dst, _3)
let src := add(_2, _3)
if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_uint16(src))
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd)
value2 := abi_decode_t_uint16(add(headStart, 64))
value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint256_$30_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 1056) { revert(value2, value2) }
if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(value2, value2) }
let _1 := 0x1e
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let dst_1 := dst
let src := headStart
let _2 := add(headStart, 960)
if gt(_2, dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
let _3 := 0x20
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd)
value2 := abi_decode_t_uint16(add(headStart, 992))
value3 := abi_decode_t_address(add(headStart, 1024))
}
function abi_decode_tuple_t_array$_t_uint256_$31_memory_ptrt_array$_t_string_memory_ptr_$20_memory_ptrt_contract$_C_$164t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 1088) { revert(value2, value2) }
let _1 := 0x1f
if iszero(slt(add(headStart, _1), dataEnd)) { revert(value2, value2) }
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let dst_1 := dst
let src := headStart
let _2 := add(headStart, 992)
if gt(_2, dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
let _3 := 0x20
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$20_memory_ptr(add(headStart, offset), dataEnd)
value2 := abi_decode_t_address(add(headStart, 1024))
value3 := abi_decode_t_address(add(headStart, 1056))
}
function abi_decode_tuple_t_array$_t_uint256_$32_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint32t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 1120) { revert(value2, value2) }
if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(value2, value2) }
let _1 := 0x20
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let dst_1 := dst
let src := headStart
let _2 := add(headStart, 1024)
if gt(_2, dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
dst := add(dst, _1)
src := add(src, _1)
}
value0 := dst_1
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd)
value2 := abi_decode_t_uint32(add(headStart, 1056))
value3 := abi_decode_t_address(add(headStart, 1088))
}
function abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(value2, value2) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst_1 := dst
mstore(dst, length)
let _3 := 0x20
dst := add(dst, _3)
let src := add(_2, _3)
if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd)
value2 := abi_decode_t_uint16(add(headStart, 64))
value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint32_$dyn_memory_ptrt_array$_t_string_memory_ptr_$12_memory_ptrt_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptrt_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(value2, value2) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst_1 := dst
mstore(dst, length)
let _3 := 0x20
dst := add(dst, _3)
let src := add(_2, _3)
if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_uint32(src))
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$12_memory_ptr(add(headStart, offset_1), dataEnd)
let offset_2 := calldataload(add(headStart, 64))
if gt(offset_2, _1) { revert(value2, value2) }
value2 := abi_decode_t_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptr(add(headStart, offset_2), dataEnd)
value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0
{
if slt(sub(dataEnd, headStart), 32) { revert(value0, value0) }
value0 := calldataload(headStart)
}
function abi_encode_t_array$_t_uint16_$dyn_memory_ptr_to_t_array$_t_uint16_$dyn_memory_ptr_fromStack(value, pos) -> end
{
let length := mload(value)
mstore(pos, length)
let _1 := 0x20
pos := add(pos, _1)
let srcPtr := add(value, _1)
let i := end
for { } lt(i, length) { i := add(i, 1) }
{
mstore(pos, and(mload(srcPtr), 0xffff))
pos := add(pos, _1)
srcPtr := add(srcPtr, _1)
}
end := pos
}
function abi_encode_tuple_t_array$_t_bytes_memory_ptr_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_bytes_memory_ptr_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(headStart, value0, value1) -> tail
{
let tail_1 := add(headStart, 64)
mstore(headStart, 64)
let pos := tail_1
let length := mload(value0)
mstore(tail_1, length)
pos := add(headStart, 96)
let _1 := 0x20
let tail_2 := add(add(headStart, mul(length, _1)), 96)
let srcPtr := add(value0, _1)
let i := tail
for { } lt(i, length) { i := add(i, 1) }
{
mstore(pos, add(sub(tail_2, headStart), not(95)))
let _2 := mload(srcPtr)
let length_1 := mload(_2)
mstore(tail_2, length_1)
let i_1 := tail
for { } lt(i_1, length_1) { i_1 := add(i_1, _1) }
{
mstore(add(add(tail_2, i_1), _1), mload(add(add(_2, i_1), _1)))
}
if gt(i_1, length_1)
{
mstore(add(add(tail_2, length_1), _1), tail)
}
tail_2 := add(add(tail_2, and(add(length_1, 31), not(31))), _1)
srcPtr := add(srcPtr, _1)
pos := add(pos, _1)
}
mstore(add(headStart, _1), sub(tail_2, headStart))
tail := abi_encode_t_array$_t_uint16_$dyn_memory_ptr_to_t_array$_t_uint16_$dyn_memory_ptr_fromStack(value1, tail_2)
}
function abi_encode_tuple_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(headStart, value0, value1) -> tail
{
let _1 := 6432
let pos := headStart
pos := headStart
let srcPtr := value0
let i := tail
for { } lt(i, 0xc8) { i := add(i, 1) }
{
mstore(pos, and(mload(srcPtr), 0xffff))
let _2 := 0x20
pos := add(pos, _2)
srcPtr := add(srcPtr, _2)
}
mstore(add(headStart, 6400), _1)
tail := abi_encode_t_array$_t_uint16_$dyn_memory_ptr_to_t_array$_t_uint16_$dyn_memory_ptr_fromStack(value1, add(headStart, _1))
}
function abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(headStart, value0, value1) -> tail
{
let tail_1 := add(headStart, 64)
mstore(headStart, 64)
let pos := tail_1
let length := mload(value0)
mstore(tail_1, length)
pos := add(headStart, 96)
let _1 := 0x20
let srcPtr := add(value0, _1)
let i := tail
for { } lt(i, length) { i := add(i, 1) }
{
mstore(pos, mload(srcPtr))
pos := add(pos, _1)
srcPtr := add(srcPtr, _1)
}
mstore(add(headStart, _1), sub(pos, headStart))
tail := abi_encode_t_array$_t_uint16_$dyn_memory_ptr_to_t_array$_t_uint16_$dyn_memory_ptr_fromStack(value1, pos)
}
function abi_encode_tuple_t_uint256__to_t_uint256__fromStack(headStart, value0) -> tail
{
tail := add(headStart, 32)
mstore(headStart, value0)
}
function allocateMemory(size) -> memPtr
{
memPtr := mload(64)
let newFreePtr := add(memPtr, size)
if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { revert(0, 0) }
mstore(64, newFreePtr)
}
function array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length) -> size
{
if gt(length, 0xffffffffffffffff) { revert(size, size) }
size := add(mul(length, 0x20), 0x20)
}
function array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(length) -> size
{
if gt(length, 0xffffffffffffffff) { revert(size, size) }
size := mul(length, 0x20)
}
function fun_f6_120() -> vloc__114_mpos, vloc__117_mpos
{
let _1 := 6400
let memPtr := allocateMemory(_1)
calldatacopy(memPtr, calldatasize(), _1)
vloc__114_mpos := memPtr
vloc__117_mpos := 96
}
function getter_fun_b_6(key) -> ret
{
if iszero(lt(key, sload(1))) { invalid() }
mstore(ret, 1)
ret := sload(add(keccak256(ret, 0x20), key))
}
}
}
}
Raw
old.yul
Optimized IR:
/*******************************************************
* WARNING *
* Solidity to Yul compilation is still EXPERIMENTAL *
* It can result in LOSS OF FUNDS or worse *
* !USE AT YOUR OWN RISK! *
*******************************************************/
object "C_164" {
code {
{
mstore(64, 128)
if callvalue() { revert(0, 0) }
let _1 := datasize("C_164_deployed")
codecopy(0, dataoffset("C_164_deployed"), _1)
return(0, _1)
}
}
object "C_164_deployed" {
code {
{
mstore(64, 128)
let _1 := 4
if iszero(lt(calldatasize(), _1))
{
let _2 := 0
switch shr(224, calldataload(_2))
case 0x0dbe671f {
if callvalue() { revert(_2, _2) }
abi_decode_tuple_(_1, calldatasize())
let ret := sload(_2)
let memPos := allocateMemory(_2)
return(memPos, sub(abi_encode_tuple_t_uint256__to_t_uint256__fromStack(memPos, ret), memPos))
}
case 0x19da7652 {
if callvalue() { revert(_2, _2) }
let param, param_1, param_2, param_3 := abi_decode_tuple_t_array$_t_uint256_$30_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(_1, calldatasize())
let vloc__114_mpos, vloc__117_mpos := fun_f6_120()
let memPos_1 := allocateMemory(_2)
return(memPos_1, sub(abi_encode_tuple_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_1, vloc__114_mpos, vloc__117_mpos), memPos_1))
}
case 0x3a69a8c8 {
if callvalue() { revert(_2, _2) }
let param_4, param_5, param_6, param_7 := abi_decode_tuple_t_array$_t_uint16_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(_1, calldatasize())
let memPos_2 := allocateMemory(_2)
return(memPos_2, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_2, 96, 96), memPos_2))
}
case 0x40b9ccd0 {
if callvalue() { revert(_2, _2) }
let param_8, param_9, param_10, param_11 := abi_decode_tuple_t_array$_t_uint32_$dyn_memory_ptrt_array$_t_string_memory_ptr_$12_memory_ptrt_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptrt_address(_1, calldatasize())
let memPos_3 := allocateMemory(_2)
return(memPos_3, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_3, 96, 96), memPos_3))
}
case 0x66941981 {
if callvalue() { revert(_2, _2) }
let param_12, param_13, param_14, param_15 := abi_decode_tuple_t_array$_t_address_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_bytes_memory_ptrt_address(_1, calldatasize())
let memPos_4 := allocateMemory(_2)
return(memPos_4, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_4, 96, 96), memPos_4))
}
case 0x8f448bde {
if callvalue() { revert(_2, _2) }
let param_16, param_17, param_18, param_19 := abi_decode_tuple_t_array$_t_uint256_$31_memory_ptrt_array$_t_string_memory_ptr_$20_memory_ptrt_contract$_C_$164t_address(_1, calldatasize())
let memPos_5 := allocateMemory(_2)
return(memPos_5, sub(abi_encode_tuple_t_array$_t_bytes_memory_ptr_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_bytes_memory_ptr_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_5, 96, 96), memPos_5))
}
case 0x931538b4 {
if callvalue() { revert(_2, _2) }
let param_20, param_21, param_22, param_23 := abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(_1, calldatasize())
let memPos_6 := allocateMemory(_2)
return(memPos_6, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_6, 96, 96), memPos_6))
}
case 0x9adbf691 {
if callvalue() { revert(_2, _2) }
pop(abi_decode_tuple_t_uint256(_1, calldatasize()))
let memPos_7 := allocateMemory(_2)
return(memPos_7, sub(abi_encode_tuple_t_uint256__to_t_uint256__fromStack(memPos_7, _2), memPos_7))
}
case 0xc94cc147 {
if callvalue() { revert(_2, _2) }
let param_24, param_25, param_26, param_27 := abi_decode_tuple_t_array$_t_uint256_$32_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint32t_address(_1, calldatasize())
let memPos_8 := allocateMemory(_2)
return(memPos_8, sub(abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(memPos_8, 96, 96), memPos_8))
}
case 0xcd580ff3 {
if callvalue() { revert(_2, _2) }
let ret_1 := getter_fun_b_6(abi_decode_tuple_t_uint256(_1, calldatasize()))
let memPos_9 := allocateMemory(_2)
return(memPos_9, sub(abi_encode_tuple_t_uint256__to_t_uint256__fromStack(memPos_9, ret_1), memPos_9))
}
}
revert(0, 0)
}
function abi_decode_t_address(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }
}
function abi_decode_t_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
let length := calldataload(offset)
array := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst := array
mstore(array, length)
let _1 := 0x20
dst := add(array, _1)
let src := add(offset, _1)
let i := 0
for { } lt(i, length) { i := add(i, 1) }
{
let _2 := add(offset, calldataload(src))
if iszero(slt(add(_2, 63), end)) { revert(0, 0) }
let _3 := 0x02
let dst_1 := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_3))
let dst_2 := dst_1
let src_1 := add(_2, _1)
let i_1 := 0
for { } lt(i_1, _3) { i_1 := add(i_1, 1) }
{
mstore(dst_1, abi_decode_t_bytes_memory_ptr(add(add(_2, calldataload(src_1)), _1), end))
dst_1 := add(dst_1, _1)
src_1 := add(src_1, _1)
}
mstore(dst, dst_2)
dst := add(dst, _1)
src := add(src, _1)
}
}
function abi_decode_t_array$_t_string_memory_ptr_$12_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
array := allocateMemory(384)
let dst := array
let src := offset
let i := 0
for { } lt(i, 0x0c) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_bytes_memory_ptr(add(offset, calldataload(src)), end))
let _1 := 0x20
dst := add(dst, _1)
src := add(src, _1)
}
}
function abi_decode_t_array$_t_string_memory_ptr_$20_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
array := allocateMemory(640)
let dst := array
let src := offset
let i := 0
for { } lt(i, 0x14) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_bytes_memory_ptr(add(offset, calldataload(src)), end))
let _1 := 0x20
dst := add(dst, _1)
src := add(src, _1)
}
}
function abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
let length := calldataload(offset)
array := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst := array
mstore(array, length)
let _1 := 0x20
dst := add(array, _1)
let src := add(offset, _1)
let i := 0
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_bytes_memory_ptr(add(add(offset, calldataload(src)), _1), end))
dst := add(dst, _1)
src := add(src, _1)
}
}
function abi_decode_t_bytes_memory_ptr(offset, end) -> array
{
if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
let length := calldataload(offset)
if gt(length, 0xffffffffffffffff) { revert(array, array) }
array := allocateMemory(add(and(add(length, 0x1f), not(31)), 0x20))
mstore(array, length)
if gt(add(add(offset, length), 0x20), end) { revert(0, 0) }
calldatacopy(add(array, 0x20), add(offset, 0x20), length)
mstore(add(add(array, length), 0x20), 0)
}
function abi_decode_t_uint16(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, 0xffff))) { revert(0, 0) }
}
function abi_decode_t_uint32(offset) -> value
{
value := calldataload(offset)
if iszero(eq(value, and(value, 0xffffffff))) { revert(0, 0) }
}
function abi_decode_tuple_(headStart, dataEnd)
{
if slt(sub(dataEnd, headStart), 0) { revert(0, 0) }
}
function abi_decode_tuple_t_array$_t_address_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_bytes_memory_ptrt_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 128) { revert(value0, value0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(value0, value0) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value0, value0) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst_1 := dst
mstore(dst, length)
let _3 := 0x20
dst := add(dst, _3)
let src := add(_2, _3)
if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(value0, value0) }
let i := value0
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_address(src))
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value1, value1) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd)
let offset_2 := calldataload(add(headStart, 64))
if gt(offset_2, _1) { revert(value2, value2) }
value2 := abi_decode_t_bytes_memory_ptr(add(headStart, offset_2), dataEnd)
value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint16_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(value2, value2) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst_1 := dst
mstore(dst, length)
let _3 := 0x20
dst := add(dst, _3)
let src := add(_2, _3)
if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_uint16(src))
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd)
value2 := abi_decode_t_uint16(add(headStart, 64))
value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint256_$30_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 1056) { revert(value2, value2) }
if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(value2, value2) }
let _1 := 0x1e
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let dst_1 := dst
let src := headStart
let _2 := add(headStart, 960)
if gt(_2, dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
let _3 := 0x20
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd)
value2 := abi_decode_t_uint16(add(headStart, 992))
value3 := abi_decode_t_address(add(headStart, 1024))
}
function abi_decode_tuple_t_array$_t_uint256_$31_memory_ptrt_array$_t_string_memory_ptr_$20_memory_ptrt_contract$_C_$164t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 1088) { revert(value2, value2) }
let _1 := 0x1f
if iszero(slt(add(headStart, _1), dataEnd)) { revert(value2, value2) }
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let dst_1 := dst
let src := headStart
let _2 := add(headStart, 992)
if gt(_2, dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
let _3 := 0x20
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$20_memory_ptr(add(headStart, offset), dataEnd)
value2 := abi_decode_t_address(add(headStart, 1024))
value3 := abi_decode_t_address(add(headStart, 1056))
}
function abi_decode_tuple_t_array$_t_uint256_$32_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint32t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 1120) { revert(value2, value2) }
if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(value2, value2) }
let _1 := 0x20
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let dst_1 := dst
let src := headStart
let _2 := add(headStart, 1024)
if gt(_2, dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
dst := add(dst, _1)
src := add(src, _1)
}
value0 := dst_1
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd)
value2 := abi_decode_t_uint32(add(headStart, 1056))
value3 := abi_decode_t_address(add(headStart, 1088))
}
function abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(value2, value2) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst_1 := dst
mstore(dst, length)
let _3 := 0x20
dst := add(dst, _3)
let src := add(_2, _3)
if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd)
value2 := abi_decode_t_uint16(add(headStart, 64))
value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_array$_t_uint32_$dyn_memory_ptrt_array$_t_string_memory_ptr_$12_memory_ptrt_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptrt_address(headStart, dataEnd) -> value0, value1, value2, value3
{
if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(value2, value2) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
let dst_1 := dst
mstore(dst, length)
let _3 := 0x20
dst := add(dst, _3)
let src := add(_2, _3)
if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(value2, value2) }
let i := value2
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_uint32(src))
dst := add(dst, _3)
src := add(src, _3)
}
value0 := dst_1
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(value2, value2) }
value1 := abi_decode_t_array$_t_string_memory_ptr_$12_memory_ptr(add(headStart, offset_1), dataEnd)
let offset_2 := calldataload(add(headStart, 64))
if gt(offset_2, _1) { revert(value2, value2) }
value2 := abi_decode_t_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptr(add(headStart, offset_2), dataEnd)
value3 := abi_decode_t_address(add(headStart, 96))
}
function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0
{
if slt(sub(dataEnd, headStart), 32) { revert(value0, value0) }
value0 := calldataload(headStart)
}
function abi_encode_t_array$_t_uint16_$dyn_memory_ptr_to_t_array$_t_uint16_$dyn_memory_ptr_fromStack(value, pos) -> end
{
let length := mload(value)
mstore(pos, length)
let _1 := 0x20
pos := add(pos, _1)
let srcPtr := add(value, _1)
let i := end
for { } lt(i, length) { i := add(i, 1) }
{
mstore(pos, and(mload(srcPtr), 0xffff))
pos := add(pos, _1)
srcPtr := add(srcPtr, _1)
}
end := pos
}
function abi_encode_tuple_t_array$_t_bytes_memory_ptr_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_bytes_memory_ptr_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(headStart, value0, value1) -> tail
{
let tail_1 := add(headStart, 64)
mstore(headStart, 64)
let pos := tail_1
let length := mload(value0)
mstore(tail_1, length)
pos := add(headStart, 96)
let _1 := 0x20
let tail_2 := add(add(headStart, mul(length, _1)), 96)
let srcPtr := add(value0, _1)
let i := tail
for { } lt(i, length) { i := add(i, 1) }
{
mstore(pos, add(sub(tail_2, headStart), not(95)))
let _2 := mload(srcPtr)
let length_1 := mload(_2)
mstore(tail_2, length_1)
let i_1 := tail
for { } lt(i_1, length_1) { i_1 := add(i_1, _1) }
{
mstore(add(add(tail_2, i_1), _1), mload(add(add(_2, i_1), _1)))
}
if gt(i_1, length_1)
{
mstore(add(add(tail_2, length_1), _1), tail)
}
tail_2 := add(add(tail_2, and(add(length_1, 31), not(31))), _1)
srcPtr := add(srcPtr, _1)
pos := add(pos, _1)
}
mstore(add(headStart, _1), sub(tail_2, headStart))
tail := abi_encode_t_array$_t_uint16_$dyn_memory_ptr_to_t_array$_t_uint16_$dyn_memory_ptr_fromStack(value1, tail_2)
}
function abi_encode_tuple_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint16_$200_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(headStart, value0, value1) -> tail
{
let _1 := 6432
let pos := headStart
pos := headStart
let srcPtr := value0
let i := tail
for { } lt(i, 0xc8) { i := add(i, 1) }
{
mstore(pos, and(mload(srcPtr), 0xffff))
let _2 := 0x20
pos := add(pos, _2)
srcPtr := add(srcPtr, _2)
}
mstore(add(headStart, 6400), _1)
tail := abi_encode_t_array$_t_uint16_$dyn_memory_ptr_to_t_array$_t_uint16_$dyn_memory_ptr_fromStack(value1, add(headStart, _1))
}
function abi_encode_tuple_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__to_t_array$_t_uint256_$dyn_memory_ptr_t_array$_t_uint16_$dyn_memory_ptr__fromStack(headStart, value0, value1) -> tail
{
let tail_1 := add(headStart, 64)
mstore(headStart, 64)
let pos := tail_1
let length := mload(value0)
mstore(tail_1, length)
pos := add(headStart, 96)
let _1 := 0x20
let srcPtr := add(value0, _1)
let i := tail
for { } lt(i, length) { i := add(i, 1) }
{
mstore(pos, mload(srcPtr))
pos := add(pos, _1)
srcPtr := add(srcPtr, _1)
}
mstore(add(headStart, _1), sub(pos, headStart))
tail := abi_encode_t_array$_t_uint16_$dyn_memory_ptr_to_t_array$_t_uint16_$dyn_memory_ptr_fromStack(value1, pos)
}
function abi_encode_tuple_t_uint256__to_t_uint256__fromStack(headStart, value0) -> tail
{
tail := add(headStart, 32)
mstore(headStart, value0)
}
function allocateMemory(size) -> memPtr
{
memPtr := mload(64)
let newFreePtr := add(memPtr, size)
if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { revert(0, 0) }
mstore(64, newFreePtr)
}
function array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length) -> size
{
if gt(length, 0xffffffffffffffff) { revert(size, size) }
size := add(mul(length, 0x20), 0x20)
}
function array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(length) -> size
{
if gt(length, 0xffffffffffffffff) { revert(size, size) }
size := mul(length, 0x20)
}
function fun_f6_120() -> vloc__114_mpos, vloc__117_mpos
{
let _1 := 6400
let memPtr := allocateMemory(_1)
calldatacopy(memPtr, calldatasize(), _1)
vloc__114_mpos := memPtr
vloc__117_mpos := 96
}
function getter_fun_b_6(key) -> ret
{
if iszero(lt(key, sload(1))) { invalid() }
mstore(ret, 1)
ret := sload(add(keccak256(ret, 0x20), key))
}
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment