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

#
#  Panoramix v4 Oct 2019
#  Decompiled source of 0x94edc4a3065a7A42DB6C57614E513992b2eb3EE4
#
#  Let's make the world open source
#
#
#  I failed with these:
#  - unknownc6554888(?)
#  - _fallback()
#  All the rest is below.
#

def unknownd23d1161(addr _param1, uint256 _param2) payable:
  require calldata.size - 4 >= 64
  if 0xb640e3210a187b1d0cd1544caba0de58d025ce52 != caller:
      revert with 0, 'E4'
  mem[196 len 64] = transfer(address to, uint256 value), 0x52a16a4d8d18b48edca85306, 0, Mask(224, 32, _param2) >> 32
  call _param1.0x42ed6e44 with:
       gas gas_remaining wei
      args Mask(224, 32, _param2) << 224, mem[260 len 4]
  if not return_data.size:
      if not ext_call.success:
          revert with 0, 'E0'
      if not transfer(address to, uint256 value), 0x52a16a4d8d18b48edca85306:
          revert with 0, 'E0'
  else:
      mem[228 len return_data.size] = ext_call.return_data[0 len return_data.size]
      if not ext_call.success:
          revert with 0, 'E0'
      if return_data.size:
          require return_data.size >= 32
          if not mem[228]:
              revert with 0, 'E0'

def deposit(address _token, uint256 _amount) payable:
  require calldata.size - 4 >= 64
  if 0xb640e3210a187b1d0cd1544caba0de58d025ce52 != caller:
      revert with 0, 'E3'
  mem[228 len 96] = transferFrom(address from, address to, uint256 value), caller, addr(this.address), Mask(224, 32, _amount) >> 32
  call _token with:
       gas gas_remaining wei
      args Mask(224, 32, _amount) << 480, mem[324 len 4]
  if not return_data.size:
      if not ext_call.success:
          revert with 0, 'E1'
      if not transferFrom(address from, address to, uint256 value), Mask(224, 32, caller) >> 32:
          revert with 0, 'E1'
  else:
      mem[260 len return_data.size] = ext_call.return_data[0 len return_data.size]
      if not ext_call.success:
          revert with 0, 'E1'
      if return_data.size:
          require return_data.size >= 32
          if not mem[260]:
              revert with 0, 'E1'

def unknowne88ce6e0(uint8 _param1, uint256 _param2, array _param3): # not payable
  require calldata.size - 4 >= 96
  require _param3 <= 4294967296
  require _param3 + 36 <= calldata.size
  require _param3.length <= 4294967296 and _param3 + _param3.length + 36 <= calldata.size
  if 0xcf6b5af89b9aeea8739fd709dc8776e732f1273c != caller:
      if 0xb640e3210a187b1d0cd1544caba0de58d025ce52 != caller:
          revert with 0, 'E2'
  idx = 0
  s = 0
  while uint8(idx) < 2 * _param1 % 128:
      create2 contract with 0 wei
                      salt: (_param2 + idx)
                      code: _param3[all]
      idx = idx + 2
      s = create2.new_address
      continue
  mem[ceil32(_param3.length) + 128] = addr(r * uint255(None + 1) >> 1)
  log 0xb9cf7541: Mask(8 * -ceil32(_param3.length) + _param3.length + 32, 0, 0), mem[_param3.length + 160 len -_param3.length + ceil32(_param3.length)]

def unknown6cb8cdda(uint256 _param1, uint256 _param2, uint128 _param3, uint128 _param4, addr _param5) payable:
  require calldata.size - 4 >= 160
  if 0xb640e3210a187b1d0cd1544caba0de58d025ce52 != caller:
      revert with 0, 'E5'
  if not Mask(1, 3, block.gasprice):
      if block.coinbase == 0x99c85bb64564d9ef9a99621301f22c9993cb89e3:
          revert with 0, 'EE1'
      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
      static call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).getReserves() with:
              gas gas_remaining wei
      if not ext_call.success:
          revert with ext_call.return_data[0 len return_data.size]
      require return_data.size >= 96
      if Mask(1, 1, block.gasprice):
          if bool(block.gasprice) != 1:
              if not Mask(1, 4, block.gasprice):
                  if 997 * _param4 / 997 != _param4:
                      revert with 0, 'mul-overflow'
                  if not ext_call.return_data[50 len 14]:
                      if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                          revert with 0, 'mul-overflow'
                      if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                          revert with 0, 'add-overflow'
                      require (1000 * ext_call.return_data * _param4)
                      require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                      call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                           gas gas_remaining wei
                          args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
                      require return_data.size >= 32
                      require ext_call.return_data[0]
                      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                      if Mask(1, 2, block.gasprice):
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                      else:
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      require ext_call.return_data[50 len 14]
                      if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                          revert with 0, 'mul-overflow'
                      if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                          revert with 0, 'mul-overflow'
                      if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                          revert with 0, 'add-overflow'
                      require (1000 * ext_call.return_data * _param4)
                      require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                      call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                           gas gas_remaining wei
                          args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
                      require return_data.size >= 32
                      require ext_call.return_data[0]
                      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                      if Mask(1, 2, block.gasprice):
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                      else:
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
              else:
                  call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                       gas gas_remaining wei
                  if 997 * _param4 / 997 != _param4:
                      revert with 0, 'mul-overflow'
                  if not Mask(112, 0, ext_call.return_data[32]):
                      if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                          revert with 0, 'mul-overflow'
                      if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                          revert with 0, 'add-overflow'
                      require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                      require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                      call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                           gas gas_remaining wei
                          args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
                      require return_data.size >= 32
                      require ext_call.return_data[0]
                      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                      if Mask(1, 2, block.gasprice):
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                      else:
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      require Mask(112, 0, ext_call.return_data[32])
                      if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                          revert with 0, 'mul-overflow'
                      if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                          revert with 0, 'mul-overflow'
                      if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                          revert with 0, 'add-overflow'
                      require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                      require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                      call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                           gas gas_remaining wei
                          args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
                      require return_data.size >= 32
                      require ext_call.return_data[0]
                      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                      if Mask(1, 2, block.gasprice):
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                      else:
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
              if not ext_call.success:
                  revert with ext_call.return_data[0 len return_data.size]
          else:
              if Mask(112, 0, _param3) >= ext_call.return_data[18 len 14]:
                  if not Mask(1, 4, block.gasprice):
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not ext_call.return_data[50 len 14]:
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require ext_call.return_data[50 len 14]
                          if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                           gas gas_remaining wei
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not Mask(112, 0, ext_call.return_data[32]):
                          if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                              revert with 0, 'mul-overflow'
                          if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                              revert with 0, 'add-overflow'
                          require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require Mask(112, 0, ext_call.return_data[32])
                          if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                              revert with 0, 'mul-overflow'
                          if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                              revert with 0, 'add-overflow'
                          require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  if not ext_call.success:
                      revert with ext_call.return_data[0 len return_data.size]
      else:
          if bool(block.gasprice) != 1:
              if not Mask(1, 4, block.gasprice):
                  if 997 * _param4 / 997 != _param4:
                      revert with 0, 'mul-overflow'
                  if not ext_call.return_data[18 len 14]:
                      if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                          revert with 0, 'mul-overflow'
                      if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                          revert with 0, 'add-overflow'
                      require (1000 * ext_call.return_data * _param4)
                      require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                      call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                           gas gas_remaining wei
                          args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
                      require return_data.size >= 32
                      require ext_call.return_data[0]
                      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                      if Mask(1, 2, block.gasprice):
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                      else:
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      require ext_call.return_data[18 len 14]
                      if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                          revert with 0, 'mul-overflow'
                      if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                          revert with 0, 'mul-overflow'
                      if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                          revert with 0, 'add-overflow'
                      require (1000 * ext_call.return_data * _param4)
                      require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                      call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                           gas gas_remaining wei
                          args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
                      require return_data.size >= 32
                      require ext_call.return_data[0]
                      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                      if Mask(1, 2, block.gasprice):
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                      else:
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
              else:
                  call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                       gas gas_remaining wei
                  if 997 * _param4 / 997 != _param4:
                      revert with 0, 'mul-overflow'
                  if not Mask(112, 0, ext_call.return_data[0]):
                      if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                          revert with 0, 'mul-overflow'
                      if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                          revert with 0, 'add-overflow'
                      require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                      require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                      call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                           gas gas_remaining wei
                          args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
                      require return_data.size >= 32
                      require ext_call.return_data[0]
                      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                      if Mask(1, 2, block.gasprice):
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                      else:
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      require Mask(112, 0, ext_call.return_data[0])
                      if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                          revert with 0, 'mul-overflow'
                      if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                          revert with 0, 'mul-overflow'
                      if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                          revert with 0, 'add-overflow'
                      require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                      require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                      call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                           gas gas_remaining wei
                          args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
                      require return_data.size >= 32
                      require ext_call.return_data[0]
                      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                      if Mask(1, 2, block.gasprice):
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                      else:
                          call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                               gas gas_remaining wei
                              args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
              if not ext_call.success:
                  revert with ext_call.return_data[0 len return_data.size]
          else:
              if Mask(112, 0, _param3) >= ext_call.return_data[50 len 14]:
                  if not Mask(1, 4, block.gasprice):
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not ext_call.return_data[18 len 14]:
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require ext_call.return_data[18 len 14]
                          if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                           gas gas_remaining wei
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not Mask(112, 0, ext_call.return_data[0]):
                          if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                              revert with 0, 'mul-overflow'
                          if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                              revert with 0, 'add-overflow'
                          require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require Mask(112, 0, ext_call.return_data[0])
                          if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                              revert with 0, 'mul-overflow'
                          if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                              revert with 0, 'add-overflow'
                          require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  if not ext_call.success:
                      revert with ext_call.return_data[0 len return_data.size]
  else:
      call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1, _param2)) with:
           gas gas_remaining wei
      if block.coinbase == 0x99c85bb64564d9ef9a99621301f22c9993cb89e3:
          revert with 0, 'EE1'
      require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
      static call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).getReserves() with:
              gas gas_remaining wei
      if not ext_call.success:
          revert with ext_call.return_data[0 len return_data.size]
      require return_data.size >= 96
      if not return_data.size:
          if Mask(1, 1, block.gasprice):
              if bool(block.gasprice) != 1:
                  if not Mask(1, 4, block.gasprice):
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not ext_call.return_data[50 len 14]:
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require ext_call.return_data[50 len 14]
                          if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                           gas gas_remaining wei
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not Mask(112, 0, ext_call.return_data[32]):
                          if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                              revert with 0, 'mul-overflow'
                          if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                              revert with 0, 'add-overflow'
                          require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require Mask(112, 0, ext_call.return_data[32])
                          if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                              revert with 0, 'mul-overflow'
                          if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                              revert with 0, 'add-overflow'
                          require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  if not ext_call.success:
                      revert with ext_call.return_data[0 len return_data.size]
              else:
                  if Mask(112, 0, _param3) >= ext_call.return_data[18 len 14]:
                      if not Mask(1, 4, block.gasprice):
                          if 997 * _param4 / 997 != _param4:
                              revert with 0, 'mul-overflow'
                          if not ext_call.return_data[50 len 14]:
                              if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                                  revert with 0, 'mul-overflow'
                              if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                                  revert with 0, 'add-overflow'
                              require (1000 * ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require ext_call.return_data[50 len 14]
                              if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                                  revert with 0, 'mul-overflow'
                              if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                                  revert with 0, 'mul-overflow'
                              if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                                  revert with 0, 'add-overflow'
                              require (1000 * ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                               gas gas_remaining wei
                          if 997 * _param4 / 997 != _param4:
                              revert with 0, 'mul-overflow'
                          if not Mask(112, 0, ext_call.return_data[32]):
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0, 'mul-overflow'
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0, 'add-overflow'
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require Mask(112, 0, ext_call.return_data[32])
                              if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                  revert with 0, 'mul-overflow'
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0, 'mul-overflow'
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0, 'add-overflow'
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
          else:
              if bool(block.gasprice) != 1:
                  if not Mask(1, 4, block.gasprice):
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not ext_call.return_data[18 len 14]:
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require ext_call.return_data[18 len 14]
                          if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                           gas gas_remaining wei
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not Mask(112, 0, ext_call.return_data[0]):
                          if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                              revert with 0, 'mul-overflow'
                          if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                              revert with 0, 'add-overflow'
                          require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require Mask(112, 0, ext_call.return_data[0])
                          if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                              revert with 0, 'mul-overflow'
                          if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                              revert with 0, 'add-overflow'
                          require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  if not ext_call.success:
                      revert with ext_call.return_data[0 len return_data.size]
              else:
                  if Mask(112, 0, _param3) >= ext_call.return_data[50 len 14]:
                      if not Mask(1, 4, block.gasprice):
                          if 997 * _param4 / 997 != _param4:
                              revert with 0, 'mul-overflow'
                          if not ext_call.return_data[18 len 14]:
                              if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                                  revert with 0, 'mul-overflow'
                              if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                                  revert with 0, 'add-overflow'
                              require (1000 * ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require ext_call.return_data[18 len 14]
                              if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                                  revert with 0, 'mul-overflow'
                              if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                                  revert with 0, 'mul-overflow'
                              if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                                  revert with 0, 'add-overflow'
                              require (1000 * ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                               gas gas_remaining wei
                          if 997 * _param4 / 997 != _param4:
                              revert with 0, 'mul-overflow'
                          if not Mask(112, 0, ext_call.return_data[0]):
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0, 'mul-overflow'
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0, 'add-overflow'
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require Mask(112, 0, ext_call.return_data[0])
                              if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                  revert with 0, 'mul-overflow'
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0, 'mul-overflow'
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0, 'add-overflow'
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
      else:
          if Mask(1, 1, block.gasprice):
              if bool(block.gasprice) != 1:
                  if not Mask(1, 4, block.gasprice):
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not ext_call.return_data[50 len 14]:
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require ext_call.return_data[50 len 14]
                          if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                           gas gas_remaining wei
                      if not return_data.size:
                          if 997 * _param4 / 997 != _param4:
                              revert with 0, 'mul-overflow'
                          if not Mask(112, 0, ext_call.return_data[32]):
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0, 'mul-overflow'
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0, 'add-overflow'
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require Mask(112, 0, ext_call.return_data[32])
                              if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                  revert with 0, 'mul-overflow'
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0, 'mul-overflow'
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0, 'add-overflow'
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          if 997 * _param4 / 997 != _param4:
                              revert with 0,
                                          'mul-overflow',
                                          mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                          if not Mask(112, 0, ext_call.return_data[32]):
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0,
                                              'mul-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0,
                                              'add-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4 << 128, mem[(2 * ceil32(return_data.size)) + 400 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require Mask(112, 0, ext_call.return_data[32])
                              if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                  revert with 0,
                                              'mul-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0,
                                              'mul-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                  revert with 0,
                                              'add-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4 << 128, mem[(2 * ceil32(return_data.size)) + 400 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  if not ext_call.success:
                      revert with ext_call.return_data[0 len return_data.size]
              else:
                  if Mask(112, 0, _param3) >= ext_call.return_data[18 len 14]:
                      if not Mask(1, 4, block.gasprice):
                          if 997 * _param4 / 997 != _param4:
                              revert with 0, 'mul-overflow'
                          if not ext_call.return_data[50 len 14]:
                              if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                                  revert with 0, 'mul-overflow'
                              if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                                  revert with 0, 'add-overflow'
                              require (1000 * ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require ext_call.return_data[50 len 14]
                              if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                                  revert with 0, 'mul-overflow'
                              if 1000 * ext_call.return_data / 1000 != ext_call.return_data[18 len 14]:
                                  revert with 0, 'mul-overflow'
                              if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[18 len 14]:
                                  revert with 0, 'add-overflow'
                              require (1000 * ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                               gas gas_remaining wei
                          if not return_data.size:
                              if 997 * _param4 / 997 != _param4:
                                  revert with 0, 'mul-overflow'
                              if not Mask(112, 0, ext_call.return_data[32]):
                                  if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                      revert with 0, 'mul-overflow'
                                  if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                      revert with 0, 'add-overflow'
                                  require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                                  require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                                  call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                       gas gas_remaining wei
                                      args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
                                  require return_data.size >= 32
                                  require ext_call.return_data[0]
                                  require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                                  if Mask(1, 2, block.gasprice):
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                                  else:
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                              else:
                                  require Mask(112, 0, ext_call.return_data[32])
                                  if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                      revert with 0, 'mul-overflow'
                                  if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                      revert with 0, 'mul-overflow'
                                  if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                      revert with 0, 'add-overflow'
                                  require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                                  require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                                  call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                       gas gas_remaining wei
                                      args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
                                  require return_data.size >= 32
                                  require ext_call.return_data[0]
                                  require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                                  if Mask(1, 2, block.gasprice):
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                                  else:
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              if 997 * _param4 / 997 != _param4:
                                  revert with 0,
                                              'mul-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if not Mask(112, 0, ext_call.return_data[32]):
                                  if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                      revert with 0,
                                                  'mul-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                      revert with 0,
                                                  'add-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                                  require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                                  call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                       gas gas_remaining wei
                                      args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4 << 128, mem[(2 * ceil32(return_data.size)) + 400 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
                                  require return_data.size >= 32
                                  require ext_call.return_data[0]
                                  require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                                  if Mask(1, 2, block.gasprice):
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                                  else:
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                              else:
                                  require Mask(112, 0, ext_call.return_data[32])
                                  if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                      revert with 0,
                                                  'mul-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[0]):
                                      revert with 0,
                                                  'mul-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[0]):
                                      revert with 0,
                                                  'add-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                                  require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                                  call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                       gas gas_remaining wei
                                      args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4 << 128, mem[(2 * ceil32(return_data.size)) + 400 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
                                  require return_data.size >= 32
                                  require ext_call.return_data[0]
                                  require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                                  if Mask(1, 2, block.gasprice):
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                                  else:
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]
          else:
              if bool(block.gasprice) != 1:
                  if not Mask(1, 4, block.gasprice):
                      if 997 * _param4 / 997 != _param4:
                          revert with 0, 'mul-overflow'
                      if not ext_call.return_data[18 len 14]:
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          require ext_call.return_data[18 len 14]
                          if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                              revert with 0, 'mul-overflow'
                          if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                              revert with 0, 'mul-overflow'
                          if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                              revert with 0, 'add-overflow'
                          require (1000 * ext_call.return_data * _param4)
                          require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                          call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                               gas gas_remaining wei
                              args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                          if not ext_call.success:
                              revert with ext_call.return_data[0 len return_data.size]
                          require return_data.size >= 32
                          require ext_call.return_data[0]
                          require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                          if Mask(1, 2, block.gasprice):
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                          else:
                              call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                   gas gas_remaining wei
                                  args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  else:
                      call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                           gas gas_remaining wei
                      if not return_data.size:
                          if 997 * _param4 / 997 != _param4:
                              revert with 0, 'mul-overflow'
                          if not Mask(112, 0, ext_call.return_data[0]):
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0, 'mul-overflow'
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0, 'add-overflow'
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require Mask(112, 0, ext_call.return_data[0])
                              if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                  revert with 0, 'mul-overflow'
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0, 'mul-overflow'
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0, 'add-overflow'
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          if 997 * _param4 / 997 != _param4:
                              revert with 0,
                                          'mul-overflow',
                                          mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                          if not Mask(112, 0, ext_call.return_data[0]):
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0,
                                              'mul-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0,
                                              'add-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4 << 128, mem[(2 * ceil32(return_data.size)) + 400 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require Mask(112, 0, ext_call.return_data[0])
                              if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                  revert with 0,
                                              'mul-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0,
                                              'mul-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                  revert with 0,
                                              'add-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4 << 128, mem[(2 * ceil32(return_data.size)) + 400 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                  if not ext_call.success:
                      revert with ext_call.return_data[0 len return_data.size]
              else:
                  if Mask(112, 0, _param3) >= ext_call.return_data[50 len 14]:
                      if not Mask(1, 4, block.gasprice):
                          if 997 * _param4 / 997 != _param4:
                              revert with 0, 'mul-overflow'
                          if not ext_call.return_data[18 len 14]:
                              if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                                  revert with 0, 'mul-overflow'
                              if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                                  revert with 0, 'add-overflow'
                              require (1000 * ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              require ext_call.return_data[18 len 14]
                              if 997 * _param4 * ext_call.return_data / ext_call.return_data * _param4:
                                  revert with 0, 'mul-overflow'
                              if 1000 * ext_call.return_data / 1000 != ext_call.return_data[50 len 14]:
                                  revert with 0, 'mul-overflow'
                              if (1000 * ext_call.return_data * _param4) < 1000 * ext_call.return_data[50 len 14]:
                                  revert with 0, 'add-overflow'
                              require (1000 * ext_call.return_data * _param4)
                              require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                              call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                   gas gas_remaining wei
                                  args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                              if not ext_call.success:
                                  revert with ext_call.return_data[0 len return_data.size]
                              require return_data.size >= 32
                              require ext_call.return_data[0]
                              require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                              if Mask(1, 2, block.gasprice):
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                              else:
                                  call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                       gas gas_remaining wei
                                      args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      else:
                          call addr(sha3(0, Mask(160, 96, this.address) >> 96, _param1 + 2, _param2)) with:
                               gas gas_remaining wei
                          if not return_data.size:
                              if 997 * _param4 / 997 != _param4:
                                  revert with 0, 'mul-overflow'
                              if not Mask(112, 0, ext_call.return_data[0]):
                                  if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                      revert with 0, 'mul-overflow'
                                  if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                      revert with 0, 'add-overflow'
                                  require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                                  require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                                  call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                       gas gas_remaining wei
                                      args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
                                  require return_data.size >= 32
                                  require ext_call.return_data[0]
                                  require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                                  if Mask(1, 2, block.gasprice):
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                                  else:
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                              else:
                                  require Mask(112, 0, ext_call.return_data[0])
                                  if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                      revert with 0, 'mul-overflow'
                                  if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                      revert with 0, 'mul-overflow'
                                  if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                      revert with 0, 'add-overflow'
                                  require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                                  require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                                  call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                       gas gas_remaining wei
                                      args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
                                  require return_data.size >= 32
                                  require ext_call.return_data[0]
                                  require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                                  if Mask(1, 2, block.gasprice):
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                                  else:
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                          else:
                              if 997 * _param4 / 997 != _param4:
                                  revert with 0,
                                              'mul-overflow',
                                              mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                              if not Mask(112, 0, ext_call.return_data[0]):
                                  if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                      revert with 0,
                                                  'mul-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                      revert with 0,
                                                  'add-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                                  require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                                  call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                       gas gas_remaining wei
                                      args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4 << 128, mem[(2 * ceil32(return_data.size)) + 400 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
                                  require return_data.size >= 32
                                  require ext_call.return_data[0]
                                  require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                                  if Mask(1, 2, block.gasprice):
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0, 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                                  else:
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0 / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                              else:
                                  require Mask(112, 0, ext_call.return_data[0])
                                  if 997 * _param4 * Mask(112, 0, ext_call.return_data / Mask(112, 0, ext_call.return_data * _param4:
                                      revert with 0,
                                                  'mul-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if 1000 * Mask(112, 0, ext_call.return_data / 1000 != Mask(112, 0, ext_call.return_data[32]):
                                      revert with 0,
                                                  'mul-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if (1000 * Mask(112, 0, ext_call.return_data * _param4) < 1000 * Mask(112, 0, ext_call.return_data[32]):
                                      revert with 0,
                                                  'add-overflow',
                                                  mem[(2 * ceil32(return_data.size)) + 432 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  require (1000 * Mask(112, 0, ext_call.return_data * _param4)
                                  require ext_code.size(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
                                  call 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.transfer(address to, uint256 value) with:
                                       gas gas_remaining wei
                                      args addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)), _param4 << 128, mem[(2 * ceil32(return_data.size)) + 400 len (2 * ceil32(return_data.size)) - (2 * ceil32(return_data.size))]
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
                                  require return_data.size >= 32
                                  require ext_call.return_data[0]
                                  require ext_code.size(addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)))
                                  if Mask(1, 2, block.gasprice):
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 0, 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), this.address, 128, 0
                                  else:
                                      call addr(_param5 xor uint32(block.gasprice) + (uint32(block.gasprice) << 32) + (uint32(block.gasprice) << 64) + (uint32(block.gasprice) << 96) + (uint32(block.gasprice) << 128)).0x22c0d9f with:
                                           gas gas_remaining wei
                                          args 997 * _param4 * Mask(112, 0, ext_call.return_data / (1000 * Mask(112, 0, ext_call.return_data * _param4), 0, this.address, 128, 0
                      if not ext_call.success:
                          revert with ext_call.return_data[0 len return_data.size]