Skip to content

Instantly share code, notes, and snippets.

@hrkrshnn

hrkrshnn/diff.diff

Last active July 22, 2020 10:23
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save hrkrshnn/7c14cfa1794271792fbf5f36e0d6cfda to your computer and use it in GitHub Desktop.
Save hrkrshnn/7c14cfa1794271792fbf5f36e0d6cfda to your computer and use it in GitHub Desktop.
Download ZIP
Raw
diff.diff
diff -u /tmp/abiOpt.yul /tmp/new.yul
--- /tmp/abiOpt.yul 2020-07-16 17:41:26.225218259 +0530
+++ /tmp/new.yul 2020-07-22 15:29:25.538743429 +0530
@@ -34,38 +34,38 @@
}
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())
+ 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())
+ 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())
+ 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())
+ 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())
+ 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())
+ 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))
}
@@ -77,7 +77,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())
+ 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))
}
@@ -112,7 +112,7 @@
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 array_1 := dst_1
let src_1 := add(_2, _1)
let i_1 := 0
for { } lt(i_1, _3) { i_1 := add(i_1, 1) }
@@ -121,7 +121,7 @@
dst_1 := add(dst_1, _1)
src_1 := add(src_1, _1)
}
- mstore(dst, dst_2)
+ mstore(dst, array_1)
dst := add(dst, _1)
src := add(src, _1)
}
@@ -199,79 +199,74 @@
{
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
+ 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)
{
- if slt(sub(dataEnd, headStart), 128) { revert(value0, value0) }
+ if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
- if gt(offset, _1) { revert(value0, value0) }
+ if gt(offset, _1) { revert(0, 0) }
let _2 := add(headStart, offset)
- if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value0, value0) }
+ if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
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
+ if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(0, 0) }
+ let i := 0
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)
+ if gt(offset_1, _1) { revert(0, 0) }
+ pop(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))
+ if gt(offset_2, _1) { revert(0, 0) }
+ pop(abi_decode_t_bytes_memory_ptr(add(headStart, offset_2), dataEnd))
+ pop(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
+ function abi_decode_tuple_t_array$_t_uint16_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd)
{
- if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
+ if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
- if gt(offset, _1) { revert(value2, value2) }
+ if gt(offset, _1) { revert(0, 0) }
let _2 := add(headStart, offset)
- if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
+ if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
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
+ if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(0, 0) }
+ let i := 0
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))
+ if gt(offset_1, _1) { revert(0, 0) }
+ pop(abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd))
+ pop(abi_decode_t_uint16(add(headStart, 64)))
+ pop(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
+ function abi_decode_tuple_t_array$_t_uint256_$30_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd)
{
- if slt(sub(dataEnd, headStart), 1056) { revert(value2, value2) }
- if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(value2, value2) }
+ if slt(sub(dataEnd, headStart), 1056) { revert(0, 0) }
+ if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(0, 0) }
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
+ if gt(_2, dataEnd) { revert(0, 0) }
+ let i := 0
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
@@ -279,24 +274,22 @@
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))
+ if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
+ pop(abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd))
+ pop(abi_decode_t_uint16(add(headStart, 992)))
+ pop(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
+ 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)
{
- if slt(sub(dataEnd, headStart), 1088) { revert(value2, value2) }
+ if slt(sub(dataEnd, headStart), 1088) { revert(0, 0) }
let _1 := 0x1f
- if iszero(slt(add(headStart, _1), dataEnd)) { revert(value2, value2) }
+ if iszero(slt(add(headStart, _1), dataEnd)) { revert(0, 0) }
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
+ if gt(_2, dataEnd) { revert(0, 0) }
+ let i := 0
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
@@ -304,98 +297,91 @@
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))
+ if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
+ pop(abi_decode_t_array$_t_string_memory_ptr_$20_memory_ptr(add(headStart, offset), dataEnd))
+ pop(abi_decode_t_address(add(headStart, 1024)))
+ pop(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
+ function abi_decode_tuple_t_array$_t_uint256_$32_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint32t_address(headStart, dataEnd)
{
- if slt(sub(dataEnd, headStart), 1120) { revert(value2, value2) }
- if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(value2, value2) }
+ if slt(sub(dataEnd, headStart), 1120) { revert(0, 0) }
+ if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(0, 0) }
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
+ if gt(_2, dataEnd) { revert(0, 0) }
+ let i := 0
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))
+ if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
+ pop(abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd))
+ pop(abi_decode_t_uint32(add(headStart, 1056)))
+ pop(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
+ function abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptrt_array$_t_string_memory_ptr_$dyn_memory_ptrt_uint16t_address(headStart, dataEnd)
{
- if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
+ if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
- if gt(offset, _1) { revert(value2, value2) }
+ if gt(offset, _1) { revert(0, 0) }
let _2 := add(headStart, offset)
- if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
+ if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
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
+ if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(0, 0) }
+ let i := 0
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))
+ if gt(offset_1, _1) { revert(0, 0) }
+ pop(abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd))
+ pop(abi_decode_t_uint16(add(headStart, 64)))
+ pop(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
+ 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)
{
- if slt(sub(dataEnd, headStart), 128) { revert(value2, value2) }
+ if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
- if gt(offset, _1) { revert(value2, value2) }
+ if gt(offset, _1) { revert(0, 0) }
let _2 := add(headStart, offset)
- if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(value2, value2) }
+ if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
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
+ if gt(add(add(_2, mul(length, _3)), _3), dataEnd) { revert(0, 0) }
+ let i := 0
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)
+ if gt(offset_1, _1) { revert(0, 0) }
+ pop(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))
+ if gt(offset_2, _1) { revert(0, 0) }
+ pop(abi_decode_t_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptr(add(headStart, offset_2), dataEnd))
+ pop(abi_decode_t_address(add(headStart, 96)))
}
function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0
{
Diff finished. Wed Jul 22 15:35:39 2020
Raw
only-arguments.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
remove-return.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) }
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) }
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) }
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) }
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) }
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) }
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) }
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 array_1 := 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, array_1)
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)
{
if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(0, 0) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
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(0, 0) }
let i := 0
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_address(src))
dst := add(dst, _3)
src := add(src, _3)
}
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(0, 0) }
pop(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(0, 0) }
pop(abi_decode_t_bytes_memory_ptr(add(headStart, offset_2), dataEnd))
pop(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)
{
if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(0, 0) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
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(0, 0) }
let i := 0
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_uint16(src))
dst := add(dst, _3)
src := add(src, _3)
}
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(0, 0) }
pop(abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd))
pop(abi_decode_t_uint16(add(headStart, 64)))
pop(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)
{
if slt(sub(dataEnd, headStart), 1056) { revert(0, 0) }
if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(0, 0) }
let _1 := 0x1e
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let src := headStart
let _2 := add(headStart, 960)
if gt(_2, dataEnd) { revert(0, 0) }
let i := 0
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
let _3 := 0x20
dst := add(dst, _3)
src := add(src, _3)
}
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
pop(abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd))
pop(abi_decode_t_uint16(add(headStart, 992)))
pop(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)
{
if slt(sub(dataEnd, headStart), 1088) { revert(0, 0) }
let _1 := 0x1f
if iszero(slt(add(headStart, _1), dataEnd)) { revert(0, 0) }
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let src := headStart
let _2 := add(headStart, 992)
if gt(_2, dataEnd) { revert(0, 0) }
let i := 0
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
let _3 := 0x20
dst := add(dst, _3)
src := add(src, _3)
}
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
pop(abi_decode_t_array$_t_string_memory_ptr_$20_memory_ptr(add(headStart, offset), dataEnd))
pop(abi_decode_t_address(add(headStart, 1024)))
pop(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)
{
if slt(sub(dataEnd, headStart), 1120) { revert(0, 0) }
if iszero(slt(add(headStart, 0x1f), dataEnd)) { revert(0, 0) }
let _1 := 0x20
let dst := allocateMemory(array_allocation_size_t_array$_t_bytes_memory_ptr_$2_memory_ptr(_1))
let src := headStart
let _2 := add(headStart, 1024)
if gt(_2, dataEnd) { revert(0, 0) }
let i := 0
for { } lt(i, _1) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
dst := add(dst, _1)
src := add(src, _1)
}
let offset := calldataload(_2)
if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
pop(abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset), dataEnd))
pop(abi_decode_t_uint32(add(headStart, 1056)))
pop(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)
{
if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(0, 0) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
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(0, 0) }
let i := 0
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, calldataload(src))
dst := add(dst, _3)
src := add(src, _3)
}
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(0, 0) }
pop(abi_decode_t_array$_t_string_memory_ptr_$dyn_memory_ptr(add(headStart, offset_1), dataEnd))
pop(abi_decode_t_uint16(add(headStart, 64)))
pop(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)
{
if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
let offset := calldataload(headStart)
let _1 := 0xffffffffffffffff
if gt(offset, _1) { revert(0, 0) }
let _2 := add(headStart, offset)
if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
let length := calldataload(_2)
let dst := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory_ptr(length))
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(0, 0) }
let i := 0
for { } lt(i, length) { i := add(i, 1) }
{
mstore(dst, abi_decode_t_uint32(src))
dst := add(dst, _3)
src := add(src, _3)
}
let offset_1 := calldataload(add(headStart, _3))
if gt(offset_1, _1) { revert(0, 0) }
pop(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(0, 0) }
pop(abi_decode_t_array$_t_array$_t_bytes_memory_ptr_$2_memory_ptr_$dyn_memory_ptr(add(headStart, offset_2), dataEnd))
pop(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
running isoltest
gasTests/abiv2_optimised.sol: FAIL
Contract:
pragma experimental ABIEncoderV2;
contract C {
uint public a;
uint[] public b;
function f1(uint) public pure returns (uint) { }
function f2(uint[] memory, string[] memory, uint16, address) public returns (uint[] memory, uint16[] memory) {}
function f3(uint16[] memory, string[] memory, uint16, address) public returns (uint[] memory, uint16[] memory) {}
function f4(uint32[] memory, string[12] memory, bytes[2][] memory, address) public returns (uint[] memory, uint16[] memory) {}
function f5(address[] memory, string[] memory, bytes memory, address) public returns (uint[] memory, uint16[] memory) {}
function f6(uint[30] memory, string[] memory, uint16, address) public returns (uint16[200] memory, uint16[] memory) {}
function f7(uint[31] memory, string[20] memory, C, address) public returns (bytes[] memory, uint16[] memory) {}
function f8(uint[32] memory, string[] memory, uint32, address) public returns (uint[] memory, uint16[] memory) {}
}
// ====
// optimize: true
// optimize-yul: true
Expected:
creation:
codeDepositCost: 600400
executionCost: 632
totalCost: 601032
external:
a(): 1029
b(uint256): 2084
f1(uint256): 351
f2(uint256[],string[],uint16,address): infinite
f3(uint16[],string[],uint16,address): infinite
f4(uint32[],string[12],bytes[2][],address): infinite
f5(address[],string[],bytes,address): infinite
f6(uint256[30],string[],uint16,address): infinite
f7(uint256[31],string[20],address,address): infinite
f8(uint256[32],string[],uint32,address): infinite
Obtained:
creation:
codeDepositCost: 631600
executionCost: 664
totalCost: 632264
external:
a(): 1029
b(uint256): 2084
f1(uint256): 351
f2(uint256[],string[],uint16,address): infinite
f3(uint16[],string[],uint16,address): infinite
f4(uint32[],string[12],bytes[2][],address): infinite
f5(address[],string[],bytes,address): infinite
f6(uint256[30],string[],uint16,address): infinite
f7(uint256[31],string[20],address,address): infinite
f8(uint256[32],string[],uint32,address): infinite
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment