1. /**
    2.  *Submitted for verification at Etherscan.io on 2020-12-18
    3. */
    5. /**
    6. * https://tornado.cash
    7. *
    8. * d888888P                                           dP              a88888b.                   dP
    9. *    88                                              88             d8'   `88                   88
    10. *    88    .d8888b. 88d888b. 88d888b. .d8888b. .d888b88 .d8888b.    88        .d8888b. .d8888b. 88d888b.
    11. *    88    88'  `88 88'  `88 88'  `88 88'  `88 88'  `88 88'  `88    88        88'  `88 Y8ooooo. 88'  `88
    12. *    88    88.  .88 88       88    88 88.  .88 88.  .88 88.  .88 dP Y8.   .88 88.  .88       88 88    88
    13. *    dP    `88888P' dP       dP    dP `88888P8 `88888P8 `88888P' 88  Y88888P' `88888P8 `88888P' dP    dP
    14. * ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
    15. */
    17. // File: @openzeppelin/contracts/token/ERC20/IERC20.sol
    19. pragma solidity ^0.5.0 || ^0.6.0 || ^0.7.0;
    21. /**
    22.  * @dev Interface of the ERC20 standard as defined in the EIP.
    23.  */
    24. interface IERC20 {
    25.     /**
    26.      * @dev Returns the amount of tokens in existence.
    27.      */
    28.     function totalSupply() external view returns (uint256);
    30.     /**
    31.      * @dev Returns the amount of tokens owned by `account`.
    32.      */
    33.     function balanceOf(address account) external view returns (uint256);
    35.     /**
    36.      * @dev Moves `amount` tokens from the caller's account to `recipient`.
    37.      *
    38.      * Returns a boolean value indicating whether the operation succeeded.
    39.      *
    40.      * Emits a {Transfer} event.
    41.      */
    42.     function transfer(address recipient, uint256 amount) external returns (bool);
    44.     /**
    45.      * @dev Returns the remaining number of tokens that `spender` will be
    46.      * allowed to spend on behalf of `owner` through {transferFrom}. This is
    47.      * zero by default.
    48.      *
    49.      * This value changes when {approve} or {transferFrom} are called.
    50.      */
    51.     function allowance(address owner, address spender) external view returns (uint256);
    53.     /**
    54.      * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
    55.      *
    56.      * Returns a boolean value indicating whether the operation succeeded.
    57.      *
    58.      * IMPORTANT: Beware that changing an allowance with this method brings the risk
    59.      * that someone may use both the old and the new allowance by unfortunate
    60.      * transaction ordering. One possible solution to mitigate this race
    61.      * condition is to first reduce the spender's allowance to 0 and set the
    62.      * desired value afterwards:
    63.      * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    64.      *
    65.      * Emits an {Approval} event.
    66.      */
    67.     function approve(address spender, uint256 amount) external returns (bool);
    69.     /**
    70.      * @dev Moves `amount` tokens from `sender` to `recipient` using the
    71.      * allowance mechanism. `amount` is then deducted from the caller's
    72.      * allowance.
    73.      *
    74.      * Returns a boolean value indicating whether the operation succeeded.
    75.      *
    76.      * Emits a {Transfer} event.
    77.      */
    78.     function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    80.     /**
    81.      * @dev Emitted when `value` tokens are moved from one account (`from`) to
    82.      * another (`to`).
    83.      *
    84.      * Note that `value` may be zero.
    85.      */
    86.     event Transfer(address indexed from, address indexed to, uint256 value);
    88.     /**
    89.      * @dev Emitted when the allowance of a `spender` for an `owner` is set by
    90.      * a call to {approve}. `value` is the new allowance.
    91.      */
    92.     event Approval(address indexed owner, address indexed spender, uint256 value);
    93. }
    95. // File: @openzeppelin/contracts/math/SafeMath.sol
    99. pragma solidity ^0.6.0;
    101. /**
    102.  * @dev Wrappers over Solidity's arithmetic operations with added overflow
    103.  * checks.
    104.  *
    105.  * Arithmetic operations in Solidity wrap on overflow. This can easily result
    106.  * in bugs, because programmers usually assume that an overflow raises an
    107.  * error, which is the standard behavior in high level programming languages.
    108.  * `SafeMath` restores this intuition by reverting the transaction when an
    109.  * operation overflows.
    110.  *
    111.  * Using this library instead of the unchecked operations eliminates an entire
    112.  * class of bugs, so it's recommended to use it always.
    113.  */
    114. library SafeMath {
    115.     /**
    116.      * @dev Returns the addition of two unsigned integers, reverting on
    117.      * overflow.
    118.      *
    119.      * Counterpart to Solidity's `+` operator.
    120.      *
    121.      * Requirements:
    122.      *
    123.      * - Addition cannot overflow.
    124.      */
    125.     function add(uint256 a, uint256 b) internal pure returns (uint256) {
    126.         uint256 c = a + b;
    127.         require(c >= a, "SafeMath: addition overflow");
    129.         return c;
    130.     }
    132.     /**
    133.      * @dev Returns the subtraction of two unsigned integers, reverting on
    134.      * overflow (when the result is negative).
    135.      *
    136.      * Counterpart to Solidity's `-` operator.
    137.      *
    138.      * Requirements:
    139.      *
    140.      * - Subtraction cannot overflow.
    141.      */
    142.     function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    143.         return sub(a, b, "SafeMath: subtraction overflow");
    144.     }
    146.     /**
    147.      * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
    148.      * overflow (when the result is negative).
    149.      *
    150.      * Counterpart to Solidity's `-` operator.
    151.      *
    152.      * Requirements:
    153.      *
    154.      * - Subtraction cannot overflow.
    155.      */
    156.     function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    157.         require(b <= a, errorMessage);
    158.         uint256 c = a - b;
    160.         return c;
    161.     }
    163.     /**
    164.      * @dev Returns the multiplication of two unsigned integers, reverting on
    165.      * overflow.
    166.      *
    167.      * Counterpart to Solidity's `*` operator.
    168.      *
    169.      * Requirements:
    170.      *
    171.      * - Multiplication cannot overflow.
    172.      */
    173.     function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    174.         // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    175.         // benefit is lost if 'b' is also tested.
    176.         // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
    177.         if (a == 0) {
    178.             return 0;
    179.         }
    181.         uint256 c = a * b;
    182.         require(c / a == b, "SafeMath: multiplication overflow");
    184.         return c;
    185.     }
    187.     /**
    188.      * @dev Returns the integer division of two unsigned integers. Reverts on
    189.      * division by zero. The result is rounded towards zero.
    190.      *
    191.      * Counterpart to Solidity's `/` operator. Note: this function uses a
    192.      * `revert` opcode (which leaves remaining gas untouched) while Solidity
    193.      * uses an invalid opcode to revert (consuming all remaining gas).
    194.      *
    195.      * Requirements:
    196.      *
    197.      * - The divisor cannot be zero.
    198.      */
    199.     function div(uint256 a, uint256 b) internal pure returns (uint256) {
    200.         return div(a, b, "SafeMath: division by zero");
    201.     }
    203.     /**
    204.      * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
    205.      * division by zero. The result is rounded towards zero.
    206.      *
    207.      * Counterpart to Solidity's `/` operator. Note: this function uses a
    208.      * `revert` opcode (which leaves remaining gas untouched) while Solidity
    209.      * uses an invalid opcode to revert (consuming all remaining gas).
    210.      *
    211.      * Requirements:
    212.      *
    213.      * - The divisor cannot be zero.
    214.      */
    215.     function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    216.         require(b > 0, errorMessage);
    217.         uint256 c = a / b;
    218.         // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    220.         return c;
    221.     }
    223.     /**
    224.      * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
    225.      * Reverts when dividing by zero.
    226.      *
    227.      * Counterpart to Solidity's `%` operator. This function uses a `revert`
    228.      * opcode (which leaves remaining gas untouched) while Solidity uses an
    229.      * invalid opcode to revert (consuming all remaining gas).
    230.      *
    231.      * Requirements:
    232.      *
    233.      * - The divisor cannot be zero.
    234.      */
    235.     function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    236.         return mod(a, b, "SafeMath: modulo by zero");
    237.     }
    239.     /**
    240.      * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
    241.      * Reverts with custom message when dividing by zero.
    242.      *
    243.      * Counterpart to Solidity's `%` operator. This function uses a `revert`
    244.      * opcode (which leaves remaining gas untouched) while Solidity uses an
    245.      * invalid opcode to revert (consuming all remaining gas).
    246.      *
    247.      * Requirements:
    248.      *
    249.      * - The divisor cannot be zero.
    250.      */
    251.     function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    252.         require(b != 0, errorMessage);
    253.         return a % b;
    254.     }
    255. }
    257. // File: @openzeppelin/contracts/utils/Address.sol
    261. pragma solidity ^0.6.2;
    263. /**
    264.  * @dev Collection of functions related to the address type
    265.  */
    266. library Address {
    267.     /**
    268.      * @dev Returns true if `account` is a contract.
    269.      *
    270.      * [IMPORTANT]
    271.      * ====
    272.      * It is unsafe to assume that an address for which this function returns
    273.      * false is an externally-owned account (EOA) and not a contract.
    274.      *
    275.      * Among others, `isContract` will return false for the following
    276.      * types of addresses:
    277.      *
    278.      *  - an externally-owned account
    279.      *  - a contract in construction
    280.      *  - an address where a contract will be created
    281.      *  - an address where a contract lived, but was destroyed
    282.      * ====
    283.      */
    284.     function isContract(address account) internal view returns (bool) {
    285.         // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
    286.         // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
    287.         // for accounts without code, i.e. `keccak256('')`
    288.         bytes32 codehash;
    289.         bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
    290.         // solhint-disable-next-line no-inline-assembly
    291.         assembly { codehash := extcodehash(account) }
    292.         return (codehash != accountHash && codehash != 0x0);
    293.     }
    295.     /**
    296.      * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
    297.      * `recipient`, forwarding all available gas and reverting on errors.
    298.      *
    299.      * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
    300.      * of certain opcodes, possibly making contracts go over the 2300 gas limit
    301.      * imposed by `transfer`, making them unable to receive funds via
    302.      * `transfer`. {sendValue} removes this limitation.
    303.      *
    304.      * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
    305.      *
    306.      * IMPORTANT: because control is transferred to `recipient`, care must be
    307.      * taken to not create reentrancy vulnerabilities. Consider using
    308.      * {ReentrancyGuard} or the
    309.      * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
    310.      */
    311.     function sendValue(address payable recipient, uint256 amount) internal {
    312.         require(address(this).balance >= amount, "Address: insufficient balance");
    314.         // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
    315.         (bool success, ) = recipient.call{ value: amount }("");
    316.         require(success, "Address: unable to send value, recipient may have reverted");
    317.     }
    319.     /**
    320.      * @dev Performs a Solidity function call using a low level `call`. A
    321.      * plain`call` is an unsafe replacement for a function call: use this
    322.      * function instead.
    323.      *
    324.      * If `target` reverts with a revert reason, it is bubbled up by this
    325.      * function (like regular Solidity function calls).
    326.      *
    327.      * Returns the raw returned data. To convert to the expected return value,
    328.      * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
    329.      *
    330.      * Requirements:
    331.      *
    332.      * - `target` must be a contract.
    333.      * - calling `target` with `data` must not revert.
    334.      *
    335.      * _Available since v3.1._
    336.      */
    337.     function functionCall(address target, bytes memory data) internal returns (bytes memory) {
    338.       return functionCall(target, data, "Address: low-level call failed");
    339.     }
    341.     /**
    342.      * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
    343.      * `errorMessage` as a fallback revert reason when `target` reverts.
    344.      *
    345.      * _Available since v3.1._
    346.      */
    347.     function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
    348.         return _functionCallWithValue(target, data, 0, errorMessage);
    349.     }
    351.     /**
    352.      * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
    353.      * but also transferring `value` wei to `target`.
    354.      *
    355.      * Requirements:
    356.      *
    357.      * - the calling contract must have an ETH balance of at least `value`.
    358.      * - the called Solidity function must be `payable`.
    359.      *
    360.      * _Available since v3.1._
    361.      */
    362.     function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
    363.         return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    364.     }
    366.     /**
    367.      * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
    368.      * with `errorMessage` as a fallback revert reason when `target` reverts.
    369.      *
    370.      * _Available since v3.1._
    371.      */
    372.     function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
    373.         require(address(this).balance >= value, "Address: insufficient balance for call");
    374.         return _functionCallWithValue(target, data, value, errorMessage);
    375.     }
    377.     function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
    378.         require(isContract(target), "Address: call to non-contract");
    380.         // solhint-disable-next-line avoid-low-level-calls
    381.         (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
    382.         if (success) {
    383.             return returndata;
    384.         } else {
    385.             // Look for revert reason and bubble it up if present
    386.             if (returndata.length > 0) {
    387.                 // The easiest way to bubble the revert reason is using memory via assembly
    389.                 // solhint-disable-next-line no-inline-assembly
    390.                 assembly {
    391.                     let returndata_size := mload(returndata)
    392.                     revert(add(32, returndata), returndata_size)
    393.                 }
    394.             } else {
    395.                 revert(errorMessage);
    396.             }
    397.         }
    398.     }
    399. }
    401. // File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
    405. pragma solidity ^0.6.0;
    410. /**
    411.  * @title SafeERC20
    412.  * @dev Wrappers around ERC20 operations that throw on failure (when the token
    413.  * contract returns false). Tokens that return no value (and instead revert or
    414.  * throw on failure) are also supported, non-reverting calls are assumed to be
    415.  * successful.
    416.  * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
    417.  * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
    418.  */
    419. library SafeERC20 {
    420.     using SafeMath for uint256;
    421.     using Address for address;
    423.     function safeTransfer(IERC20 token, address to, uint256 value) internal {
    424.         _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    425.     }
    427.     function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
    428.         _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    429.     }
    431.     /**
    432.      * @dev Deprecated. This function has issues similar to the ones found in
    433.      * {IERC20-approve}, and its usage is discouraged.
    434.      *
    435.      * Whenever possible, use {safeIncreaseAllowance} and
    436.      * {safeDecreaseAllowance} instead.
    437.      */
    438.     function safeApprove(IERC20 token, address spender, uint256 value) internal {
    439.         // safeApprove should only be called when setting an initial allowance,
    440.         // or when resetting it to zero. To increase and decrease it, use
    441.         // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
    442.         // solhint-disable-next-line max-line-length
    443.         require((value == 0) || (token.allowance(address(this), spender) == 0),
    444.             "SafeERC20: approve from non-zero to non-zero allowance"
    445.         );
    446.         _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    447.     }
    449.     function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
    450.         uint256 newAllowance = token.allowance(address(this), spender).add(value);
    451.         _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    452.     }
    454.     function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
    455.         uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
    456.         _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    457.     }
    459.     /**
    460.      * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
    461.      * on the return value: the return value is optional (but if data is returned, it must not be false).
    462.      * @param token The token targeted by the call.
    463.      * @param data The call data (encoded using abi.encode or one of its variants).
    464.      */
    465.     function _callOptionalReturn(IERC20 token, bytes memory data) private {
    466.         // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
    467.         // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
    468.         // the target address contains contract code and also asserts for success in the low-level call.
    470.         bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
    471.         if (returndata.length > 0) { // Return data is optional
    472.             // solhint-disable-next-line max-line-length
    473.             require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    474.         }
    475.     }
    476. }
    478. // File: torn-token/contracts/ENS.sol
    482. pragma solidity ^0.6.0;
    484. interface ENS {
    485.   function resolver(bytes32 node) external view returns (Resolver);
    486. }
    488. interface Resolver {
    489.   function addr(bytes32 node) external view returns (address);
    490. }
    492. contract EnsResolve {
    493.   function resolve(bytes32 node) public view virtual returns (address) {
    494.     ENS Registry = ENS(
    495.       getChainId() == 1 ? 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e : 0x8595bFb0D940DfEDC98943FA8a907091203f25EE
    496.     );
    497.     return Registry.resolver(node).addr(node);
    498.   }
    500.   function bulkResolve(bytes32[] memory domains) public view returns (address[] memory result) {
    501.     result = new address[](domains.length);
    502.     for (uint256 i = 0; i < domains.length; i++) {
    503.       result[i] = resolve(domains[i]);
    504.     }
    505.   }
    507.   function getChainId() internal pure returns (uint256) {
    508.     uint256 chainId;
    509.     assembly {
    510.       chainId := chainid()
    511.     }
    512.     return chainId;
    513.   }
    514. }
    516. // File: contracts/utils/FloatMath.sol
    518. // SPDX-License-Identifier: BSD-4-Clause
    519. /*
    520.  * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
    521.  * Author: Mikhail Vladimirov <mikhail.vladimirov@gmail.com>
    522.  */
    523. // pragma solidity ^0.5.0 || ^0.6.0 || ^0.7.0;
    524. pragma solidity ^0.6.0;
    526. /**
    527.  * Smart contract library of mathematical functions operating with signed
    528.  * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
    529.  * basically a simple fraction whose numerator is signed 128-bit integer and
    530.  * denominator is 2^64.  As long as denominator is always the same, there is no
    531.  * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
    532.  * represented by int128 type holding only the numerator.
    533.  */
    534. library FloatMath {
    535.   /*
    536.    * Minimum value signed 64.64-bit fixed point number may have.
    537.    */
    538.   int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
    540.   /*
    541.    * Maximum value signed 64.64-bit fixed point number may have.
    542.    */
    543.   int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
    545.   /**
    546.    * Convert signed 256-bit integer number into signed 64.64-bit fixed point
    547.    * number.  Revert on overflow.
    548.    *
    549.    * @param x signed 256-bit integer number
    550.    * @return signed 64.64-bit fixed point number
    551.    */
    552.   function fromInt (int256 x) internal pure returns (int128) {
    553.     require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
    554.     return int128 (x << 64);
    555.   }
    557.   /**
    558.    * Convert signed 64.64 fixed point number into signed 64-bit integer number
    559.    * rounding down.
    560.    *
    561.    * @param x signed 64.64-bit fixed point number
    562.    * @return signed 64-bit integer number
    563.    */
    564.   function toInt (int128 x) internal pure returns (int64) {
    565.     return int64 (x >> 64);
    566.   }
    568.   /**
    569.    * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
    570.    * number.  Revert on overflow.
    571.    *
    572.    * @param x unsigned 256-bit integer number
    573.    * @return signed 64.64-bit fixed point number
    574.    */
    575.   function fromUInt (uint256 x) internal pure returns (int128) {
    576.     require (x <= 0x7FFFFFFFFFFFFFFF);
    577.     return int128 (x << 64);
    578.   }
    580.   /**
    581.    * Convert signed 64.64 fixed point number into unsigned 64-bit integer
    582.    * number rounding down.  Revert on underflow.
    583.    *
    584.    * @param x signed 64.64-bit fixed point number
    585.    * @return unsigned 64-bit integer number
    586.    */
    587.   function toUInt (int128 x) internal pure returns (uint64) {
    588.     require (x >= 0);
    589.     return uint64 (x >> 64);
    590.   }
    592.   /**
    593.    * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
    594.    * number rounding down.  Revert on overflow.
    595.    *
    596.    * @param x signed 128.128-bin fixed point number
    597.    * @return signed 64.64-bit fixed point number
    598.    */
    599.   function from128x128 (int256 x) internal pure returns (int128) {
    600.     int256 result = x >> 64;
    601.     require (result >= MIN_64x64 && result <= MAX_64x64);
    602.     return int128 (result);
    603.   }
    605.   /**
    606.    * Convert signed 64.64 fixed point number into signed 128.128 fixed point
    607.    * number.
    608.    *
    609.    * @param x signed 64.64-bit fixed point number
    610.    * @return signed 128.128 fixed point number
    611.    */
    612.   function to128x128 (int128 x) internal pure returns (int256) {
    613.     return int256 (x) << 64;
    614.   }
    616.   /**
    617.    * Calculate x + y.  Revert on overflow.
    618.    *
    619.    * @param x signed 64.64-bit fixed point number
    620.    * @param y signed 64.64-bit fixed point number
    621.    * @return signed 64.64-bit fixed point number
    622.    */
    623.   function add (int128 x, int128 y) internal pure returns (int128) {
    624.     int256 result = int256(x) + y;
    625.     require (result >= MIN_64x64 && result <= MAX_64x64);
    626.     return int128 (result);
    627.   }
    629.   /**
    630.    * Calculate x - y.  Revert on overflow.
    631.    *
    632.    * @param x signed 64.64-bit fixed point number
    633.    * @param y signed 64.64-bit fixed point number
    634.    * @return signed 64.64-bit fixed point number
    635.    */
    636.   function sub (int128 x, int128 y) internal pure returns (int128) {
    637.     int256 result = int256(x) - y;
    638.     require (result >= MIN_64x64 && result <= MAX_64x64);
    639.     return int128 (result);
    640.   }
    642.   /**
    643.    * Calculate x * y rounding down.  Revert on overflow.
    644.    *
    645.    * @param x signed 64.64-bit fixed point number
    646.    * @param y signed 64.64-bit fixed point number
    647.    * @return signed 64.64-bit fixed point number
    648.    */
    649.   function mul (int128 x, int128 y) internal pure returns (int128) {
    650.     int256 result = int256(x) * y >> 64;
    651.     require (result >= MIN_64x64 && result <= MAX_64x64);
    652.     return int128 (result);
    653.   }
    655.   /**
    656.    * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
    657.    * number and y is signed 256-bit integer number.  Revert on overflow.
    658.    *
    659.    * @param x signed 64.64 fixed point number
    660.    * @param y signed 256-bit integer number
    661.    * @return signed 256-bit integer number
    662.    */
    663.   function muli (int128 x, int256 y) internal pure returns (int256) {
    664.     if (x == MIN_64x64) {
    665.       require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
    666.       y <= 0x1000000000000000000000000000000000000000000000000);
    667.       return -y << 63;
    668.     } else {
    669.       bool negativeResult = false;
    670.       if (x < 0) {
    671.         x = -x;
    672.         negativeResult = true;
    673.       }
    674.       if (y < 0) {
    675.         y = -y; // We rely on overflow behavior here
    676.         negativeResult = !negativeResult;
    677.       }
    678.       uint256 absoluteResult = mulu (x, uint256 (y));
    679.       if (negativeResult) {
    680.         require (absoluteResult <=
    681.           0x8000000000000000000000000000000000000000000000000000000000000000);
    682.         return -int256 (absoluteResult); // We rely on overflow behavior here
    683.       } else {
    684.         require (absoluteResult <=
    685.           0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    686.         return int256 (absoluteResult);
    687.       }
    688.     }
    689.   }
    691.   /**
    692.    * Calculate x * y rounding down, where x is signed 64.64 fixed point number
    693.    * and y is unsigned 256-bit integer number.  Revert on overflow.
    694.    *
    695.    * @param x signed 64.64 fixed point number
    696.    * @param y unsigned 256-bit integer number
    697.    * @return unsigned 256-bit integer number
    698.    */
    699.   function mulu (int128 x, uint256 y) internal pure returns (uint256) {
    700.     if (y == 0) return 0;
    702.     require (x >= 0);
    704.     uint256 lo = (uint256 (x) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
    705.     uint256 hi = uint256 (x) * (y >> 128);
    707.     require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    708.     hi <<= 64;
    710.     require (hi <=
    711.       0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
    712.     return hi + lo;
    713.   }
    715.   /**
    716.    * Calculate x / y rounding towards zero.  Revert on overflow or when y is
    717.    * zero.
    718.    *
    719.    * @param x signed 64.64-bit fixed point number
    720.    * @param y signed 64.64-bit fixed point number
    721.    * @return signed 64.64-bit fixed point number
    722.    */
    723.   function div (int128 x, int128 y) internal pure returns (int128) {
    724.     require (y != 0);
    725.     int256 result = (int256 (x) << 64) / y;
    726.     require (result >= MIN_64x64 && result <= MAX_64x64);
    727.     return int128 (result);
    728.   }
    730.   /**
    731.    * Calculate x / y rounding towards zero, where x and y are signed 256-bit
    732.    * integer numbers.  Revert on overflow or when y is zero.
    733.    *
    734.    * @param x signed 256-bit integer number
    735.    * @param y signed 256-bit integer number
    736.    * @return signed 64.64-bit fixed point number
    737.    */
    738.   function divi (int256 x, int256 y) internal pure returns (int128) {
    739.     require (y != 0);
    741.     bool negativeResult = false;
    742.     if (x < 0) {
    743.       x = -x; // We rely on overflow behavior here
    744.       negativeResult = true;
    745.     }
    746.     if (y < 0) {
    747.       y = -y; // We rely on overflow behavior here
    748.       negativeResult = !negativeResult;
    749.     }
    750.     uint128 absoluteResult = divuu (uint256 (x), uint256 (y));
    751.     if (negativeResult) {
    752.       require (absoluteResult <= 0x80000000000000000000000000000000);
    753.       return -int128 (absoluteResult); // We rely on overflow behavior here
    754.     } else {
    755.       require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    756.       return int128 (absoluteResult); // We rely on overflow behavior here
    757.     }
    758.   }
    760.   /**
    761.    * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
    762.    * integer numbers.  Revert on overflow or when y is zero.
    763.    *
    764.    * @param x unsigned 256-bit integer number
    765.    * @param y unsigned 256-bit integer number
    766.    * @return signed 64.64-bit fixed point number
    767.    */
    768.   function divu (uint256 x, uint256 y) internal pure returns (int128) {
    769.     require (y != 0);
    770.     uint128 result = divuu (x, y);
    771.     require (result <= uint128 (MAX_64x64));
    772.     return int128 (result);
    773.   }
    775.   /**
    776.    * Calculate -x.  Revert on overflow.
    777.    *
    778.    * @param x signed 64.64-bit fixed point number
    779.    * @return signed 64.64-bit fixed point number
    780.    */
    781.   function neg (int128 x) internal pure returns (int128) {
    782.     require (x != MIN_64x64);
    783.     return -x;
    784.   }
    786.   /**
    787.    * Calculate |x|.  Revert on overflow.
    788.    *
    789.    * @param x signed 64.64-bit fixed point number
    790.    * @return signed 64.64-bit fixed point number
    791.    */
    792.   function abs (int128 x) internal pure returns (int128) {
    793.     require (x != MIN_64x64);
    794.     return x < 0 ? -x : x;
    795.   }
    797.   /**
    798.    * Calculate 1 / x rounding towards zero.  Revert on overflow or when x is
    799.    * zero.
    800.    *
    801.    * @param x signed 64.64-bit fixed point number
    802.    * @return signed 64.64-bit fixed point number
    803.    */
    804.   function inv (int128 x) internal pure returns (int128) {
    805.     require (x != 0);
    806.     int256 result = int256 (0x100000000000000000000000000000000) / x;
    807.     require (result >= MIN_64x64 && result <= MAX_64x64);
    808.     return int128 (result);
    809.   }
    811.   /**
    812.    * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
    813.    *
    814.    * @param x signed 64.64-bit fixed point number
    815.    * @param y signed 64.64-bit fixed point number
    816.    * @return signed 64.64-bit fixed point number
    817.    */
    818.   function avg (int128 x, int128 y) internal pure returns (int128) {
    819.     return int128 ((int256 (x) + int256 (y)) >> 1);
    820.   }
    822.   /**
    823.    * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
    824.    * Revert on overflow or in case x * y is negative.
    825.    *
    826.    * @param x signed 64.64-bit fixed point number
    827.    * @param y signed 64.64-bit fixed point number
    828.    * @return signed 64.64-bit fixed point number
    829.    */
    830.   function gavg (int128 x, int128 y) internal pure returns (int128) {
    831.     int256 m = int256 (x) * int256 (y);
    832.     require (m >= 0);
    833.     require (m <
    834.       0x4000000000000000000000000000000000000000000000000000000000000000);
    835.     return int128 (sqrtu (uint256 (m)));
    836.   }
    838.   /**
    839.    * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
    840.    * and y is unsigned 256-bit integer number.  Revert on overflow.
    841.    *
    842.    * @param x signed 64.64-bit fixed point number
    843.    * @param y uint256 value
    844.    * @return signed 64.64-bit fixed point number
    845.    */
    846.   function pow (int128 x, uint256 y) internal pure returns (int128) {
    847.     uint256 absoluteResult;
    848.     bool negativeResult = false;
    849.     if (x >= 0) {
    850.       absoluteResult = powu (uint256 (x) << 63, y);
    851.     } else {
    852.       // We rely on overflow behavior here
    853.       absoluteResult = powu (uint256 (uint128 (-x)) << 63, y);
    854.       negativeResult = y & 1 > 0;
    855.     }
    857.     absoluteResult >>= 63;
    859.     if (negativeResult) {
    860.       require (absoluteResult <= 0x80000000000000000000000000000000);
    861.       return -int128 (absoluteResult); // We rely on overflow behavior here
    862.     } else {
    863.       require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    864.       return int128 (absoluteResult); // We rely on overflow behavior here
    865.     }
    866.   }
    868.   /**
    869.    * Calculate sqrt (x) rounding down.  Revert if x < 0.
    870.    *
    871.    * @param x signed 64.64-bit fixed point number
    872.    * @return signed 64.64-bit fixed point number
    873.    */
    874.   function sqrt (int128 x) internal pure returns (int128) {
    875.     require (x >= 0);
    876.     return int128 (sqrtu (uint256 (x) << 64));
    877.   }
    879.   /**
    880.    * Calculate binary logarithm of x.  Revert if x <= 0.
    881.    *
    882.    * @param x signed 64.64-bit fixed point number
    883.    * @return signed 64.64-bit fixed point number
    884.    */
    885.   function log_2 (int128 x) internal pure returns (int128) {
    886.     require (x > 0);
    888.     int256 msb = 0;
    889.     int256 xc = x;
    890.     if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
    891.     if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
    892.     if (xc >= 0x10000) { xc >>= 16; msb += 16; }
    893.     if (xc >= 0x100) { xc >>= 8; msb += 8; }
    894.     if (xc >= 0x10) { xc >>= 4; msb += 4; }
    895.     if (xc >= 0x4) { xc >>= 2; msb += 2; }
    896.     if (xc >= 0x2) msb += 1;  // No need to shift xc anymore
    898.     int256 result = msb - 64 << 64;
    899.     uint256 ux = uint256 (x) << uint256 (127 - msb);
    900.     for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
    901.       ux *= ux;
    902.       uint256 b = ux >> 255;
    903.       ux >>= 127 + b;
    904.       result += bit * int256 (b);
    905.     }
    907.     return int128 (result);
    908.   }
    910.   /**
    911.    * Calculate natural logarithm of x.  Revert if x <= 0.
    912.    *
    913.    * @param x signed 64.64-bit fixed point number
    914.    * @return signed 64.64-bit fixed point number
    915.    */
    916.   function ln (int128 x) internal pure returns (int128) {
    917.     require (x > 0);
    919.     return int128 (
    920.       uint256 (log_2 (x)) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128);
    921.   }
    923.   /**
    924.    * Calculate binary exponent of x.  Revert on overflow.
    925.    *
    926.    * @param x signed 64.64-bit fixed point number
    927.    * @return signed 64.64-bit fixed point number
    928.    */
    929.   function exp_2 (int128 x) internal pure returns (int128) {
    930.     require (x < 0x400000000000000000); // Overflow
    932.     if (x < -0x400000000000000000) return 0; // Underflow
    934.     uint256 result = 0x80000000000000000000000000000000;
    936.     if (x & 0x8000000000000000 > 0)
    937.       result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
    938.     if (x & 0x4000000000000000 > 0)
    939.       result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
    940.     if (x & 0x2000000000000000 > 0)
    941.       result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
    942.     if (x & 0x1000000000000000 > 0)
    943.       result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
    944.     if (x & 0x800000000000000 > 0)
    945.       result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
    946.     if (x & 0x400000000000000 > 0)
    947.       result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
    948.     if (x & 0x200000000000000 > 0)
    949.       result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
    950.     if (x & 0x100000000000000 > 0)
    951.       result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
    952.     if (x & 0x80000000000000 > 0)
    953.       result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
    954.     if (x & 0x40000000000000 > 0)
    955.       result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
    956.     if (x & 0x20000000000000 > 0)
    957.       result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
    958.     if (x & 0x10000000000000 > 0)
    959.       result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
    960.     if (x & 0x8000000000000 > 0)
    961.       result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
    962.     if (x & 0x4000000000000 > 0)
    963.       result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
    964.     if (x & 0x2000000000000 > 0)
    965.       result = result * 0x1000162E525EE054754457D5995292026 >> 128;
    966.     if (x & 0x1000000000000 > 0)
    967.       result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
    968.     if (x & 0x800000000000 > 0)
    969.       result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
    970.     if (x & 0x400000000000 > 0)
    971.       result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
    972.     if (x & 0x200000000000 > 0)
    973.       result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
    974.     if (x & 0x100000000000 > 0)
    975.       result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
    976.     if (x & 0x80000000000 > 0)
    977.       result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
    978.     if (x & 0x40000000000 > 0)
    979.       result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
    980.     if (x & 0x20000000000 > 0)
    981.       result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
    982.     if (x & 0x10000000000 > 0)
    983.       result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
    984.     if (x & 0x8000000000 > 0)
    985.       result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
    986.     if (x & 0x4000000000 > 0)
    987.       result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
    988.     if (x & 0x2000000000 > 0)
    989.       result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
    990.     if (x & 0x1000000000 > 0)
    991.       result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
    992.     if (x & 0x800000000 > 0)
    993.       result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
    994.     if (x & 0x400000000 > 0)
    995.       result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
    996.     if (x & 0x200000000 > 0)
    997.       result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
    998.     if (x & 0x100000000 > 0)
    999.       result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
    1000.     if (x & 0x80000000 > 0)
    1001.       result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
    1002.     if (x & 0x40000000 > 0)
    1003.       result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
    1004.     if (x & 0x20000000 > 0)
    1005.       result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
    1006.     if (x & 0x10000000 > 0)
    1007.       result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
    1008.     if (x & 0x8000000 > 0)
    1009.       result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
    1010.     if (x & 0x4000000 > 0)
    1011.       result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
    1012.     if (x & 0x2000000 > 0)
    1013.       result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
    1014.     if (x & 0x1000000 > 0)
    1015.       result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
    1016.     if (x & 0x800000 > 0)
    1017.       result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
    1018.     if (x & 0x400000 > 0)
    1019.       result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
    1020.     if (x & 0x200000 > 0)
    1021.       result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
    1022.     if (x & 0x100000 > 0)
    1023.       result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
    1024.     if (x & 0x80000 > 0)
    1025.       result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
    1026.     if (x & 0x40000 > 0)
    1027.       result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
    1028.     if (x & 0x20000 > 0)
    1029.       result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
    1030.     if (x & 0x10000 > 0)
    1031.       result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
    1032.     if (x & 0x8000 > 0)
    1033.       result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
    1034.     if (x & 0x4000 > 0)
    1035.       result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
    1036.     if (x & 0x2000 > 0)
    1037.       result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
    1038.     if (x & 0x1000 > 0)
    1039.       result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
    1040.     if (x & 0x800 > 0)
    1041.       result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
    1042.     if (x & 0x400 > 0)
    1043.       result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
    1044.     if (x & 0x200 > 0)
    1045.       result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
    1046.     if (x & 0x100 > 0)
    1047.       result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
    1048.     if (x & 0x80 > 0)
    1049.       result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
    1050.     if (x & 0x40 > 0)
    1051.       result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
    1052.     if (x & 0x20 > 0)
    1053.       result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
    1054.     if (x & 0x10 > 0)
    1055.       result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
    1056.     if (x & 0x8 > 0)
    1057.       result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
    1058.     if (x & 0x4 > 0)
    1059.       result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
    1060.     if (x & 0x2 > 0)
    1061.       result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
    1062.     if (x & 0x1 > 0)
    1063.       result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;
    1065.     result >>= uint256 (63 - (x >> 64));
    1066.     require (result <= uint256 (MAX_64x64));
    1068.     return int128 (result);
    1069.   }
    1071.   /**
    1072.    * Calculate natural exponent of x.  Revert on overflow.
    1073.    *
    1074.    * @param x signed 64.64-bit fixed point number
    1075.    * @return signed 64.64-bit fixed point number
    1076.    */
    1077.   function exp (int128 x) internal pure returns (int128) {
    1078.     require (x < 0x400000000000000000); // Overflow
    1080.     if (x < -0x400000000000000000) return 0; // Underflow
    1082.     return exp_2 (
    1083.       int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
    1084.   }
    1086.   /**
    1087.    * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
    1088.    * integer numbers.  Revert on overflow or when y is zero.
    1089.    *
    1090.    * @param x unsigned 256-bit integer number
    1091.    * @param y unsigned 256-bit integer number
    1092.    * @return unsigned 64.64-bit fixed point number
    1093.    */
    1094.   function divuu (uint256 x, uint256 y) private pure returns (uint128) {
    1095.     require (y != 0);
    1097.     uint256 result;
    1099.     if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
    1100.       result = (x << 64) / y;
    1101.     else {
    1102.       uint256 msb = 192;
    1103.       uint256 xc = x >> 192;
    1104.       if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
    1105.       if (xc >= 0x10000) { xc >>= 16; msb += 16; }
    1106.       if (xc >= 0x100) { xc >>= 8; msb += 8; }
    1107.       if (xc >= 0x10) { xc >>= 4; msb += 4; }
    1108.       if (xc >= 0x4) { xc >>= 2; msb += 2; }
    1109.       if (xc >= 0x2) msb += 1;  // No need to shift xc anymore
    1111.       result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1);
    1112.       require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    1114.       uint256 hi = result * (y >> 128);
    1115.       uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    1117.       uint256 xh = x >> 192;
    1118.       uint256 xl = x << 64;
    1120.       if (xl < lo) xh -= 1;
    1121.       xl -= lo; // We rely on overflow behavior here
    1122.       lo = hi << 128;
    1123.       if (xl < lo) xh -= 1;
    1124.       xl -= lo; // We rely on overflow behavior here
    1126.       assert (xh == hi >> 128);
    1128.       result += xl / y;
    1129.     }
    1131.     require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    1132.     return uint128 (result);
    1133.   }
    1135.   /**
    1136.    * Calculate x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point
    1137.    * number and y is unsigned 256-bit integer number.  Revert on overflow.
    1138.    *
    1139.    * @param x unsigned 129.127-bit fixed point number
    1140.    * @param y uint256 value
    1141.    * @return unsigned 129.127-bit fixed point number
    1142.    */
    1143.   function powu (uint256 x, uint256 y) private pure returns (uint256) {
    1144.     if (y == 0) return 0x80000000000000000000000000000000;
    1145.     else if (x == 0) return 0;
    1146.     else {
    1147.       int256 msb = 0;
    1148.       uint256 xc = x;
    1149.       if (xc >= 0x100000000000000000000000000000000) { xc >>= 128; msb += 128; }
    1150.       if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
    1151.       if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
    1152.       if (xc >= 0x10000) { xc >>= 16; msb += 16; }
    1153.       if (xc >= 0x100) { xc >>= 8; msb += 8; }
    1154.       if (xc >= 0x10) { xc >>= 4; msb += 4; }
    1155.       if (xc >= 0x4) { xc >>= 2; msb += 2; }
    1156.       if (xc >= 0x2) msb += 1;  // No need to shift xc anymore
    1158.       int256 xe = msb - 127;
    1159.       if (xe > 0) x >>= uint256 (xe);
    1160.       else x <<= uint256 (-xe);
    1162.       uint256 result = 0x80000000000000000000000000000000;
    1163.       int256 re = 0;
    1165.       while (y > 0) {
    1166.         if (y & 1 > 0) {
    1167.           result = result * x;
    1168.           y -= 1;
    1169.           re += xe;
    1170.           if (result >=
    1171.             0x8000000000000000000000000000000000000000000000000000000000000000) {
    1172.             result >>= 128;
    1173.             re += 1;
    1174.           } else result >>= 127;
    1175.           if (re < -127) return 0; // Underflow
    1176.           require (re < 128); // Overflow
    1177.         } else {
    1178.           x = x * x;
    1179.           y >>= 1;
    1180.           xe <<= 1;
    1181.           if (x >=
    1182.             0x8000000000000000000000000000000000000000000000000000000000000000) {
    1183.             x >>= 128;
    1184.             xe += 1;
    1185.           } else x >>= 127;
    1186.           if (xe < -127) return 0; // Underflow
    1187.           require (xe < 128); // Overflow
    1188.         }
    1189.       }
    1191.       if (re > 0) result <<= uint256 (re);
    1192.       else if (re < 0) result >>= uint256 (-re);
    1194.       return result;
    1195.     }
    1196.   }
    1198.   /**
    1199.    * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
    1200.    * number.
    1201.    *
    1202.    * @param x unsigned 256-bit integer number
    1203.    * @return unsigned 128-bit integer number
    1204.    */
    1205.   function sqrtu (uint256 x) private pure returns (uint128) {
    1206.     if (x == 0) return 0;
    1207.     else {
    1208.       uint256 xx = x;
    1209.       uint256 r = 1;
    1210.       if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; }
    1211.       if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; }
    1212.       if (xx >= 0x100000000) { xx >>= 32; r <<= 16; }
    1213.       if (xx >= 0x10000) { xx >>= 16; r <<= 8; }
    1214.       if (xx >= 0x100) { xx >>= 8; r <<= 4; }
    1215.       if (xx >= 0x10) { xx >>= 4; r <<= 2; }
    1216.       if (xx >= 0x8) { r <<= 1; }
    1217.       r = (r + x / r) >> 1;
    1218.       r = (r + x / r) >> 1;
    1219.       r = (r + x / r) >> 1;
    1220.       r = (r + x / r) >> 1;
    1221.       r = (r + x / r) >> 1;
    1222.       r = (r + x / r) >> 1;
    1223.       r = (r + x / r) >> 1; // Seven iterations should be enough
    1224.       uint256 r1 = x / r;
    1225.       return uint128 (r < r1 ? r : r1);
    1226.     }
    1227.   }
    1228. }
    1230. // File: contracts/RewardSwap.sol
    1234. pragma solidity ^0.6.0;
    1240. /**
    1241.   Let's imagine we have 1M TORN tokens for anonymity mining to distribute during 1 year (~31536000 seconds).
    1242.   The contract should constantly add liquidity to a pool of claimed rewards to TORN (REWD/TORN). At any time user can exchange REWD->TORN using
    1243.   this pool. The rate depends on current available TORN liquidity - the more TORN are withdrawn the worse the swap rate is.
    1245.   The contract starts with some virtual balance liquidity and adds some TORN tokens every second to the balance. Users will decrease
    1246.   this balance by swaps.
    1248.   Exchange rate can be calculated as following:
    1249.   BalanceAfter = BalanceBefore * e^(-rewardAmount/poolWeight)
    1250.   tokens = BalanceBefore - BalanceAfter
    1251. */
    1253. contract RewardSwap is EnsResolve {
    1254.   using SafeMath for uint256;
    1256.   uint256 public constant DURATION = 365 days;
    1258.   IERC20 public immutable torn;
    1259.   address public immutable miner;
    1260.   uint256 public immutable startTimestamp;
    1261.   uint256 public immutable initialLiquidity;
    1262.   uint256 public immutable liquidity;
    1263.   uint256 public tokensSold;
    1264.   uint256 public poolWeight;
    1266.   event Swap(address indexed recipient, uint256 pTORN, uint256 TORN);
    1267.   event PoolWeightUpdated(uint256 newWeight);
    1269.   modifier onlyMiner() {
    1270.     require(msg.sender == miner, "Only Miner contract can call");
    1271.     _;
    1272.   }
    1274.   constructor(
    1275.     bytes32 _torn,
    1276.     bytes32 _miner,
    1277.     uint256 _miningCap,
    1278.     uint256 _initialLiquidity,
    1279.     uint256 _poolWeight
    1280.   ) public {
    1281.     require(_initialLiquidity <= _miningCap, "Initial liquidity should be lower than mining cap");
    1282.     torn = IERC20(resolve(_torn));
    1283.     miner = resolve(_miner);
    1284.     initialLiquidity = _initialLiquidity;
    1285.     liquidity = _miningCap.sub(_initialLiquidity);
    1286.     poolWeight = _poolWeight;
    1287.     startTimestamp = getTimestamp();
    1288.   }
    1290.   function swap(address _recipient, uint256 _amount) external onlyMiner returns (uint256) {
    1291.     uint256 tokens = getExpectedReturn(_amount);
    1292.     tokensSold += tokens;
    1293.     require(torn.transfer(_recipient, tokens), "transfer failed");
    1294.     emit Swap(_recipient, _amount, tokens);
    1295.     return tokens;
    1296.   }
    1298.   /**
    1299.     @dev
    1300.    */
    1301.   function getExpectedReturn(uint256 _amount) public view returns (uint256) {
    1302.     uint256 oldBalance = tornVirtualBalance();
    1303.     int128 pow = FloatMath.neg(FloatMath.divu(_amount, poolWeight));
    1304.     int128 exp = FloatMath.exp(pow);
    1305.     uint256 newBalance = FloatMath.mulu(exp, oldBalance);
    1306.     return oldBalance.sub(newBalance);
    1307.   }
    1309.   function tornVirtualBalance() public view returns (uint256) {
    1310.     uint256 passedTime = getTimestamp().sub(startTimestamp);
    1311.     if (passedTime < DURATION) {
    1312.       return initialLiquidity.add(liquidity.mul(passedTime).div(DURATION)).sub(tokensSold);
    1313.     } else {
    1314.       return torn.balanceOf(address(this));
    1315.     }
    1316.   }
    1318.   function setPoolWeight(uint256 _newWeight) external onlyMiner {
    1319.     poolWeight = _newWeight;
    1320.     emit PoolWeightUpdated(_newWeight);
    1321.   }
    1323.   function getTimestamp() public view virtual returns (uint256) {
    1324.     return block.timestamp;
    1325.   }
    1326. }