Token Frax

/**
 *Submitted for verification at Etherscan.io on 2021-09-21
*/

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;

// Sources flattened with hardhat v2.6.2 https://hardhat.org

// File contracts/Common/Context.sol


/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


// File contracts/Math/SafeMath.sol


/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


// File contracts/ERC20/IERC20.sol



/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}


// File contracts/Utils/Address.sol


/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File contracts/ERC20/ERC20.sol





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20Mintable}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
 
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;
    
    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory __name, string memory __symbol) public {
        _name = __name;
        _symbol = __symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.approve(address spender, uint256 amount)
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for `accounts`'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }


    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal virtual {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of `from`'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of `from`'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:using-hooks.adoc[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}


// File contracts/ERC20/ERC20Permit/IERC20Permit.sol



/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


// File contracts/ERC20/ERC20Permit/ECDSA.sol



/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File contracts/ERC20/ERC20Permit/EIP712.sol



/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}


// File contracts/ERC20/ERC20Permit/Counters.sol



/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}


// File contracts/ERC20/ERC20Permit/ERC20Permit.sol







/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    function PERMIT_TYPEHASH() external view returns (bytes32) {
        return _PERMIT_TYPEHASH;
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}


// File contracts/Uniswap/TransferHelper.sol


// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

    function safeTransferETH(address to, uint value) internal {
        (bool success,) = to.call{value:value}(new bytes(0));
        require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
    }
}


// File contracts/Staking/Owned.sol


// https://docs.synthetix.io/contracts/Owned
contract Owned {
    address public owner;
    address public nominatedOwner;

    constructor (address _owner) public {
        require(_owner != address(0), "Owner address cannot be 0");
        owner = _owner;
        emit OwnerChanged(address(0), _owner);
    }

    function nominateNewOwner(address _owner) external onlyOwner {
        nominatedOwner = _owner;
        emit OwnerNominated(_owner);
    }

    function acceptOwnership() external {
        require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
        emit OwnerChanged(owner, nominatedOwner);
        owner = nominatedOwner;
        nominatedOwner = address(0);
    }

    modifier onlyOwner {
        require(msg.sender == owner, "Only the contract owner may perform this action");
        _;
    }

    event OwnerNominated(address newOwner);
    event OwnerChanged(address oldOwner, address newOwner);
}


// File contracts/Utils/ReentrancyGuard.sol


/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File contracts/ERC20/__CROSSCHAIN/CrossChainCanonical.sol


// ====================================================================
// |     ______                   _______                             |
// |    / _____________ __  __   / ____(_____  ____ _____  ________   |
// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
// | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
// |                                                                  |
// ====================================================================
// ======================== CrossChainCanonical =======================
// ====================================================================
// Cross-chain / non mainnet canonical token contract.
// Can accept any number of old non-canonical tokens. These will be 
// withdrawable by the owner so they can de-bridge it and get back mainnet 'real' tokens
// Does not include any spurious mainnet logic

// Frax Finance: https://github.com/FraxFinance

// Primary Author(s)
// Travis Moore: https://github.com/FortisFortuna

// Reviewer(s) / Contributor(s)
// Jason Huan: https://github.com/jasonhuan
// Sam Kazemian: https://github.com/samkazemian
// Dennis: github.com/denett





contract CrossChainCanonical is ERC20Permit, Owned, ReentrancyGuard {
    using SafeMath for uint256;

    /* ========== STATE VARIABLES ========== */

    // Core
    address public timelock_address; // Governance timelock address
    address public custodian_address; 

    // Misc
    uint256 public mint_cap;
    mapping(address => uint256[2]) public swap_fees;
    mapping(address => bool) public fee_exempt_list;

    // Acceptable old tokens
    address[] public bridge_tokens_array;
    mapping(address => bool) public bridge_tokens;

    // The addresses in this array are able to mint tokens
    address[] public minters_array;
    mapping(address => bool) public minters; // Mapping is also used for faster verification

    // Constants for various precisions
    uint256 private constant PRICE_PRECISION = 1e6;

    // Administrative booleans
    bool public exchangesPaused; // Pause old token exchanges in case of an emergency
    mapping(address => bool) public canSwap;

    /* ========== MODIFIERS ========== */

    modifier onlyByOwnGov() {
        require(msg.sender == timelock_address || msg.sender == owner, "Not owner or timelock");
        _;
    }

    modifier onlyByOwnGovCust() {
        require(msg.sender == timelock_address || msg.sender == owner || msg.sender == custodian_address, "Not owner, tlck, or custd");
        _;
    }

    modifier onlyMinters() {
       require(minters[msg.sender], "Not a minter");
        _;
    } 

    modifier onlyMintersOwnGov() {
       require(_isMinterOwnGov(msg.sender), "Not minter, owner, or tlck");
        _;
    } 

    modifier validBridgeToken(address token_address) {
       require(bridge_tokens[token_address], "Invalid old token");
        _;
    } 

    /* ========== CONSTRUCTOR ========== */

    constructor (
        string memory _name,
        string memory _symbol,
        address _creator_address,
        uint256 _initial_mint_amt,
        address _custodian_address,
        address[] memory _bridge_tokens
    ) ERC20(_name, _symbol) ERC20Permit(_name) Owned(_creator_address) {
        custodian_address = _custodian_address;

        // Initialize the starting old tokens
        for (uint256 i = 0; i < _bridge_tokens.length; i++){ 
            // Mark as accepted
            bridge_tokens[_bridge_tokens[i]] = true;

            // Add to the array
            bridge_tokens_array.push(_bridge_tokens[i]);

            // Set a small swap fee initially of 0.04%
            swap_fees[_bridge_tokens[i]] = [400, 400];

            // Make sure swapping is on
            canSwap[_bridge_tokens[i]] = true;
        }

        // Set the mint cap to the initial mint amount
        mint_cap = _initial_mint_amt;

        // Mint some canonical tokens to the creator
        super._mint(_creator_address, _initial_mint_amt);


    }

    /* ========== VIEWS ========== */

    // Helpful for UIs
    function allBridgeTokens() external view returns (address[] memory) {
        return bridge_tokens_array;
    }

    function _isMinterOwnGov(address the_address) internal view returns (bool) {
        return (the_address == timelock_address || the_address == owner || minters[the_address]);
    }

    function _isFeeExempt(address the_address) internal view returns (bool) {
        return (_isMinterOwnGov(the_address) || fee_exempt_list[the_address]);
    }

    /* ========== INTERNAL FUNCTIONS ========== */

    // Enforce a minting cap
    function _mint_capped(address account, uint256 amount) internal {
        require(totalSupply() + amount <= mint_cap, "Mint cap");
        super._mint(account, amount);
    }

    /* ========== PUBLIC FUNCTIONS ========== */

    // Exchange old tokens for these canonical tokens
    function exchangeOldForCanonical(address bridge_token_address, uint256 token_amount) external nonReentrant validBridgeToken(bridge_token_address) returns (uint256 canonical_tokens_out) {
        require(!exchangesPaused && canSwap[bridge_token_address], "Exchanges paused");

        // Pull in the old tokens
        TransferHelper.safeTransferFrom(bridge_token_address, msg.sender, address(this), token_amount);

        // Handle the fee, if applicable
        canonical_tokens_out = token_amount;
        if (!_isFeeExempt(msg.sender)) {
            canonical_tokens_out -= ((canonical_tokens_out * swap_fees[bridge_token_address][0]) / PRICE_PRECISION);
        }

        // Mint canonical tokens and give it to the sender
        _mint_capped(msg.sender, canonical_tokens_out);
    }

    // Exchange canonical tokens for old tokens
    function exchangeCanonicalForOld(address bridge_token_address, uint256 token_amount) external nonReentrant validBridgeToken(bridge_token_address) returns (uint256 bridge_tokens_out) {
        require(!exchangesPaused && canSwap[bridge_token_address], "Exchanges paused");
        
        // Burn the canonical tokens
        super._burn(msg.sender, token_amount);

        // Handle the fee, if applicable
        bridge_tokens_out = token_amount;
        if (!_isFeeExempt(msg.sender)) {
            bridge_tokens_out -= ((bridge_tokens_out * swap_fees[bridge_token_address][1]) / PRICE_PRECISION);
        }

        // Give old tokens to the sender
        TransferHelper.safeTransfer(bridge_token_address, msg.sender, bridge_tokens_out);
    }

    /* ========== MINTERS OR GOVERNANCE FUNCTIONS ========== */

    // Collect old tokens so you can de-bridge them back on mainnet
    function withdrawBridgeTokens(address bridge_token_address, uint256 bridge_token_amount) external onlyMintersOwnGov validBridgeToken(bridge_token_address) {
        TransferHelper.safeTransfer(bridge_token_address, msg.sender, bridge_token_amount);
    }

    /* ========== MINTERS ONLY ========== */

    // This function is what other minters will call to mint new tokens 
    function minter_mint(address m_address, uint256 m_amount) external onlyMinters {
        _mint_capped(m_address, m_amount);
        emit TokenMinted(msg.sender, m_address, m_amount);
    }

    // This function is what other minters will call to burn tokens
    function minter_burn(uint256 amount) external onlyMinters {
        super._burn(msg.sender, amount);
        emit TokenBurned(msg.sender, amount);
    }

    /* ========== RESTRICTED FUNCTIONS, BUT CUSTODIAN CAN CALL TOO ========== */

    function toggleExchanges() external onlyByOwnGovCust {
        exchangesPaused = !exchangesPaused;
    }

    /* ========== RESTRICTED FUNCTIONS ========== */

    function addBridgeToken(address bridge_token_address) external onlyByOwnGov {
        // Make sure the token is not already present
        for (uint i = 0; i < bridge_tokens_array.length; i++){ 
            if (bridge_tokens_array[i] == bridge_token_address){
                revert("Token already present");
            }
        }

        // Add the old token
        bridge_tokens[bridge_token_address] = true;
        bridge_tokens_array.push(bridge_token_address);

        // Turn swapping on
        canSwap[bridge_token_address] = true;

        emit BridgeTokenAdded(bridge_token_address);
    }

    function toggleBridgeToken(address bridge_token_address) external onlyByOwnGov {
        bridge_tokens[bridge_token_address] = !bridge_tokens[bridge_token_address];

        // Toggle swapping
        canSwap[bridge_token_address] = !canSwap[bridge_token_address];

        emit BridgeTokenToggled(bridge_token_address, !bridge_tokens[bridge_token_address]);
    }

    // Adds a minter address
    function addMinter(address minter_address) external onlyByOwnGov {
        require(minter_address != address(0), "Zero address detected");

        require(minters[minter_address] == false, "Address already exists");
        minters[minter_address] = true; 
        minters_array.push(minter_address);

        emit MinterAdded(minter_address);
    }

    // Remove a minter 
    function removeMinter(address minter_address) external onlyByOwnGov {
        require(minter_address != address(0), "Zero address detected");
        require(minters[minter_address] == true, "Address nonexistant");
        
        // Delete from the mapping
        delete minters[minter_address];

        // 'Delete' from the array by setting the address to 0x0
        for (uint i = 0; i < minters_array.length; i++){ 
            if (minters_array[i] == minter_address) {
                minters_array[i] = address(0); // This will leave a null in the array and keep the indices the same
                break;
            }
        }

        emit MinterRemoved(minter_address);
    }

    function setMintCap(uint256 _mint_cap) external onlyByOwnGov {
        mint_cap = _mint_cap;

        emit MintCapSet(_mint_cap);
    }

    function setSwapFees(address bridge_token_address, uint256 _bridge_to_canonical, uint256 _canonical_to_old) external onlyByOwnGov {
        swap_fees[bridge_token_address] = [_bridge_to_canonical, _canonical_to_old];
    }

    function toggleFeesForAddress(address the_address) external onlyByOwnGov {
        fee_exempt_list[the_address] = !fee_exempt_list[the_address];
    }

    function setTimelock(address new_timelock) external onlyByOwnGov {
        require(new_timelock != address(0), "Zero address detected");
        timelock_address = new_timelock;

        emit TimelockSet(new_timelock);
    }

    function setCustodian(address _custodian_address) external onlyByOwnGov {
        require(_custodian_address != address(0), "Zero address detected");
        custodian_address = _custodian_address;

        emit CustodianSet(_custodian_address);
    }

    function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyByOwnGov {
        TransferHelper.safeTransfer(address(tokenAddress), msg.sender, tokenAmount);
    }

    // Generic proxy
    function execute(
        address _to,
        uint256 _value,
        bytes calldata _data
    ) external onlyByOwnGov returns (bool, bytes memory) {
        (bool success, bytes memory result) = _to.call{value:_value}(_data);
        return (success, result);
    }

    /* ========== EVENTS ========== */

    event TokenBurned(address indexed from, uint256 amount);
    event TokenMinted(address indexed from, address indexed to, uint256 amount);
    event BridgeTokenAdded(address indexed bridge_token_address);
    event BridgeTokenToggled(address indexed bridge_token_address, bool state);
    event CollateralRatioRefreshed(uint256 global_collateral_ratio);
    event MinterAdded(address pool_address);
    event MinterRemoved(address pool_address);
    event MintCapSet(uint256 new_mint_cap);
    event TimelockSet(address new_timelock);
    event CustodianSet(address custodian_address);
}


// File contracts/ERC20/__CROSSCHAIN/CrossChainCanonicalFRAX.sol


contract CrossChainCanonicalFRAX is CrossChainCanonical {
    constructor (
        string memory _name,
        string memory _symbol,
        address _creator_address,
        uint256 _initial_mint_amt,
        address _custodian_address,
        address[] memory _bridge_tokens
    ) 
    CrossChainCanonical(_name, _symbol, _creator_address, _initial_mint_amt, _custodian_address, _bridge_tokens)
    {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_creator_address","type":"address"},{"internalType":"uint256","name":"_initial_mint_amt","type":"uint256"},{"internalType":"address","name":"_custodian_address","type":"address"},{"internalType":"address[]","name":"_bridge_tokens","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"bridge_token_address","type":"address"}],"name":"BridgeTokenAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"bridge_token_address","type":"address"},{"indexed":false,"internalType":"bool","name":"state","type":"bool"}],"name":"BridgeTokenToggled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"global_collateral_ratio","type":"uint256"}],"name":"CollateralRatioRefreshed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"custodian_address","type":"address"}],"name":"CustodianSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"new_mint_cap","type":"uint256"}],"name":"MintCapSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool_address","type":"address"}],"name":"MinterAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool_address","type":"address"}],"name":"MinterRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"new_timelock","type":"address"}],"name":"TimelockSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenBurned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"}],"name":"addBridgeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter_address","type":"address"}],"name":"addMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allBridgeTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"bridge_tokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"bridge_tokens_array","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"canSwap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"custodian_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"token_amount","type":"uint256"}],"name":"exchangeCanonicalForOld","outputs":[{"internalType":"uint256","name":"bridge_tokens_out","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"token_amount","type":"uint256"}],"name":"exchangeOldForCanonical","outputs":[{"internalType":"uint256","name":"canonical_tokens_out","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"exchangesPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"execute","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"fee_exempt_list","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mint_cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"minter_burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"m_address","type":"address"},{"internalType":"uint256","name":"m_amount","type":"uint256"}],"name":"minter_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"minters_array","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter_address","type":"address"}],"name":"removeMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_custodian_address","type":"address"}],"name":"setCustodian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mint_cap","type":"uint256"}],"name":"setMintCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"_bridge_to_canonical","type":"uint256"},{"internalType":"uint256","name":"_canonical_to_old","type":"uint256"}],"name":"setSwapFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"new_timelock","type":"address"}],"name":"setTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"swap_fees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timelock_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"}],"name":"toggleBridgeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleExchanges","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"the_address","type":"address"}],"name":"toggleFeesForAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_token_address","type":"address"},{"internalType":"uint256","name":"bridge_token_amount","type":"uint256"}],"name":"withdrawBridgeTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000edcc5884c5a8a0d2a37ffdcea589807792ca0b4c0000000000000000000000000000000000000000000034f086f3b33b68400000000000000000000000000000058b3fa36471cd10a73355fe84f7d4ed7ba4607e000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000044672617800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000446524158000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000104592a158490a9228070e0a8e5343b499e125d0

-----Decoded View---------------
Arg [0] : _name (string): Frax
Arg [1] : _symbol (string): FRAX
Arg [2] : _creator_address (address): 0xedcc5884c5a8a0d2a37ffdcea589807792ca0b4c
Arg [3] : _initial_mint_amt (uint256): 250000000000000000000000
Arg [4] : _custodian_address (address): 0x058b3fa36471cd10a73355fe84f7d4ed7ba4607e
Arg [5] : _bridge_tokens (address[]): 0x104592a158490a9228070e0a8e5343b499e125d0

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 000000000000000000000000edcc5884c5a8a0d2a37ffdcea589807792ca0b4c
Arg [3] : 0000000000000000000000000000000000000000000034f086f3b33b68400000
Arg [4] : 000000000000000000000000058b3fa36471cd10a73355fe84f7d4ed7ba4607e
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [7] : 4672617800000000000000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [9] : 4652415800000000000000000000000000000000000000000000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [11] : 000000000000000000000000104592a158490a9228070e0a8e5343b499e125d0

66659:420:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61197:256;;;;;;:::i;:::-;;:::i;:::-;;56468:27;;;;;;;;;;;;6937:14:1;;6930:22;6912:41;;6900:2;6885:18;56468:27:0;;;;;;;;19492:83;;;:::i;:::-;;;;;;;:::i;64791:152::-;;;;;;:::i;:::-;;:::i;21638:169::-;;;;;;:::i;:::-;;:::i;62898:371::-;;;;;;:::i;:::-;;:::i;62268:622::-;;;;;;:::i;:::-;;:::i;50896:141::-;;;;;;:::i;:::-;;:::i;20567:100::-;20647:12;;20567:100;;;7413:25:1;;;7401:2;7386:18;20567:100:0;7368:76:1;22279:321:0;;;;;;:::i;:::-;;:::i;60291:762::-;;;;;;:::i;:::-;;:::i;63698:706::-;;;;;;:::i;:::-;;:::i;48532:101::-;48609:16;48532:101;;20419:83;20485:9;;20419:83;;20485:9;;;;20297:36:1;;20285:2;20270:18;20419:83:0;20252:87:1;56050:36:0;;;;;;:::i;:::-;;:::i;:::-;;;4994:42:1;4982:55;;;4964:74;;4952:2;4937:18;56050:36:0;4919:125:1;48409:115:0;;;:::i;23009:218::-;;;;;;:::i;:::-;;:::i;65188:256::-;;;;;;:::i;:::-;;:::i;64412:139::-;;;;;;:::i;:::-;;:::i;25803:91::-;;;;;;:::i;:::-;;:::i;50664:29::-;;;;;;;;;61583:191;;;;;;:::i;:::-;;:::i;20730:119::-;;;;;;:::i;:::-;20823:18;;20796:7;20823:18;;;;;;;;;;;;20730:119;62098:106;;;:::i;51045:271::-;;;:::i;26211:295::-;;;;;;:::i;:::-;;:::i;55825:32::-;;;;;;;;;48151:128;;;;;;:::i;:::-;;:::i;55910:47::-;;;;;;:::i;:::-;;:::i;55964:::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;65452:181;;;;;;:::i;:::-;;:::i;50637:20::-;;;;;;;;;55880:23;;;;;;59430:804;;;;;;:::i;:::-;;:::i;56555:39::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;19694:87;;;:::i;63307:358::-;;;;;;:::i;:::-;;:::i;23730:269::-;;;;;;:::i;:::-;;:::i;64559:224::-;;;;;;:::i;:::-;;:::i;21062:175::-;;;;;;:::i;:::-;;:::i;56093:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;65663:274;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;64951:229::-;;;;;;:::i;:::-;;:::i;58575:113::-;;;:::i;:::-;;;;;;;:::i;47440:645::-;;;;;;:::i;:::-;;:::i;56207:30::-;;;;;;:::i;:::-;;:::i;55756:31::-;;;;;;;;;21300:151;;;;;;:::i;:::-;21416:18;;;;21389:7;21416:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;21300:151;56244:39;;;;;;:::i;:::-;;;;;;;;;;;;;;;;61851:155;;;;;;:::i;:::-;;:::i;61197:256::-;57144:27;57160:10;57144:15;:27::i;:::-;57136:66;;;;;;;12066:2:1;57136:66:0;;;12048:21:1;12105:2;12085:18;;;12078:30;12144:28;12124:18;;;12117:56;12190:18;;57136:66:0;;;;;;;;;57298:28:::1;::::0;::::1;;::::0;;;:13:::1;:28;::::0;;;;;61330:20;;57298:28:::1;;57290:58;;;::::0;::::1;::::0;;13485:2:1;57290:58:0::1;::::0;::::1;13467:21:1::0;13524:2;13504:18;;;13497:30;13563:19;13543:18;;;13536:47;13600:18;;57290:58:0::1;13457:167:1::0;57290:58:0::1;61363:82:::2;61391:20;61413:10;61425:19;61363:27;:82::i;:::-;57213:1:::1;61197:256:::0;;:::o;19492:83::-;19529:13;19562:5;19555:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19492:83;:::o;64791:152::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;64907:28:::1;;;::::0;;;:15:::1;:28;::::0;;;;;;64875:60;;::::1;64907:28;::::0;;::::1;64906:29;64875:60;::::0;;64791:152::o;21638:169::-;21721:4;21738:39;819:10;21761:7;21770:6;21738:8;:39::i;:::-;-1:-1:-1;21795:4:0;21638:169;;;;:::o;62898:371::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;63027:35:::1;::::0;::::1;;::::0;;;:13:::1;:35;::::0;;;;;;;;;::::1;::::0;;::::1;63026:36;62988:74:::0;;;::::1;;::::0;;63136:7:::1;:29:::0;;;;;;;;;;::::1;63135:30;63103:62:::0;::::1;::::0;;;::::1;::::0;;63225:35;;;;;63183:78;;63225:35;;;::::1;63224:36;6912:41:1::0;;63183:78:0::1;::::0;6885:18:1;63183:78:0::1;;;;;;;;62898:371:::0;:::o;62268:622::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;62415:6:::1;62410:197;62431:19;:26:::0;62427:30;::::1;62410:197;;;62509:20;62483:46;;:19;62503:1;62483:22;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;::::1;;:46;62479:117;;;62549:31;::::0;::::1;::::0;;18700:2:1;62549:31:0::1;::::0;::::1;18682:21:1::0;18739:2;18719:18;;;18712:30;18778:23;18758:18;;;18751:51;18819:18;;62549:31:0::1;18672:171:1::0;62479:117:0::1;62459:3:::0;::::1;::::0;::::1;:::i;:::-;;;;62410:197;;;-1:-1:-1::0;62649:35:0::1;::::0;::::1;;::::0;;;:13:::1;:35;::::0;;;;;;;:42;;62687:4:::1;62649:42:::0;;;::::1;::::0;::::1;::::0;;;62702:19:::1;:46:::0;;;;::::1;::::0;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;62790:7:::1;:29:::0;;;;;;:36;;;;::::1;;::::0;;;62844:38;::::1;::::0;62649:35;62844:38:::1;62268:622:::0;:::o;50896:141::-;51376:5;;;;51362:10;:19;51354:79;;;;;;;14991:2:1;51354:79:0;;;14973:21:1;15030:2;15010:18;;;15003:30;15069:34;15049:18;;;15042:62;15140:17;15120:18;;;15113:45;15175:19;;51354:79:0;14963:237:1;51354:79:0;50968:14:::1;:23:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;51007:22:::1;::::0;4964:74:1;;;51007:22:0::1;::::0;4952:2:1;4937:18;51007:22:0::1;;;;;;;;50896:141:::0;:::o;22279:321::-;22385:4;22402:36;22412:6;22420:9;22431:6;22402:9;:36::i;:::-;22449:121;22458:6;819:10;22480:89;22518:6;22480:89;;;;;;;;;;;;;;;;;:19;;;;;;;:11;:19;;;;;;;;819:10;22480:33;;;;;;;;;;:37;:89::i;:::-;22449:8;:121::i;:::-;-1:-1:-1;22588:4:0;22279:321;;;;;:::o;60291:762::-;60446:25;53270:1;53876:7;;:19;;53868:63;;;;;;;19455:2:1;53868:63:0;;;19437:21:1;19494:2;19474:18;;;19467:30;19533:33;19513:18;;;19506:61;19584:18;;53868:63:0;19427:181:1;53868:63:0;53270:1;54009:7;:18;57298:28:::1;::::0;::::1;;::::0;;;:13:::1;:28;::::0;;;;;60415:20;;57298:28:::1;;57290:58;;;::::0;::::1;::::0;;13485:2:1;57290:58:0::1;::::0;::::1;13467:21:1::0;13524:2;13504:18;;;13497:30;13563:19;13543:18;;;13536:47;13600:18;;57290:58:0::1;13457:167:1::0;57290:58:0::1;60493:15:::2;::::0;::::2;;60492:16;:49:::0;::::2;;;-1:-1:-1::0;60512:29:0::2;::::0;::::2;;::::0;;;:7:::2;:29;::::0;;;;;::::2;;60492:49;60484:78;;;::::0;::::2;::::0;;16801:2:1;60484:78:0::2;::::0;::::2;16783:21:1::0;16840:2;16820:18;;;16813:30;16879:18;16859;;;16852:46;16915:18;;60484:78:0::2;16773:166:1::0;60484:78:0::2;60621:37;60633:10;60645:12;60621:11;:37::i;:::-;60733:12;60713:32;;60761:24;60774:10;60761:12;:24::i;:::-;60756:155;;60845:31;::::0;::::2;;::::0;;;:9:::2;:31;::::0;;;;56424:3:::2;::::0;60877:1:::2;60845:34;::::0;60825:54:::2;::::0;:17;:54:::2;:::i;:::-;60824:74;;;;:::i;:::-;60802:97;::::0;;::::2;:::i;:::-;;;60756:155;60965:80;60993:20;61015:10;61027:17;60965:27;:80::i;:::-;-1:-1:-1::0;53226:1:0;54188:7;:22;60291:762;;-1:-1:-1;;60291:762:0:o;63698:706::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;63785:28:::1;::::0;::::1;63777:62;;;::::0;::::1;::::0;;12421:2:1;63777:62:0::1;::::0;::::1;12403:21:1::0;12460:2;12440:18;;;12433:30;12499:23;12479:18;;;12472:51;12540:18;;63777:62:0::1;12393:171:1::0;63777:62:0::1;63858:23;::::0;::::1;;::::0;;;:7:::1;:23;::::0;;;;;::::1;;:31;;:23:::0;:31:::1;63850:63;;;::::0;::::1;::::0;;16453:2:1;63850:63:0::1;::::0;::::1;16435:21:1::0;16492:2;16472:18;;;16465:30;16531:21;16511:18;;;16504:49;16570:18;;63850:63:0::1;16425:169:1::0;63850:63:0::1;63977:23;::::0;::::1;;::::0;;;:7:::1;:23;::::0;;;;63970:30;;;::::1;::::0;;64079:271:::1;64100:13;:20:::0;64096:24;::::1;64079:271;;;64166:14;64146:34;;:13;64160:1;64146:16;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;::::1;;:34;64142:197;;;64228:1;64201:13;64215:1;64201:16;;;;;;;;:::i;:::-;;;;;;;;;:29;;;;;;;;;;;;;;;;;;64318:5;;64142:197;64122:3:::0;::::1;::::0;::::1;:::i;:::-;;;;64079:271;;;-1:-1:-1::0;64367:29:0::1;::::0;4994:42:1;4982:55;;4964:74;;64367:29:0::1;::::0;4952:2:1;4937:18;64367:29:0::1;4919:125:1::0;56050:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56050:36:0;:::o;48409:115::-;48469:7;48496:20;:18;:20::i;:::-;48489:27;;48409:115;:::o;23009:218::-;819:10;23097:4;23146:25;;;:11;:25;;;;;;;;;:34;;;;;;;;;;23097:4;;23114:83;;23137:7;;23146:50;;23185:10;23146:38;:50::i;65188:256::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;65279:32:::1;::::0;::::1;65271:66;;;::::0;::::1;::::0;;12421:2:1;65271:66:0::1;::::0;::::1;12403:21:1::0;12460:2;12440:18;;;12433:30;12499:23;12479:18;;;12472:51;12540:18;;65271:66:0::1;12393:171:1::0;65271:66:0::1;65348:17;:38:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;65404:32:::1;::::0;4964:74:1;;;65404:32:0::1;::::0;4952:2:1;4937:18;65404:32:0::1;4919:125:1::0;64412:139:0;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;64484:8:::1;:20:::0;;;64522:21:::1;::::0;7413:25:1;;;64522:21:0::1;::::0;7401:2:1;7386:18;64522:21:0::1;7368:76:1::0;25803:91:0;25859:27;819:10;25879:6;25859:5;:27::i;:::-;25803:91;:::o;61583:191::-;57040:10;57032:19;;;;:7;:19;;;;;;;;57024:44;;;;;;;17954:2:1;57024:44:0;;;17936:21:1;17993:2;17973:18;;;17966:30;18032:14;18012:18;;;18005:42;18064:18;;57024:44:0;17926:162:1;57024:44:0;61673:33:::1;61686:9;61697:8;61673:12;:33::i;:::-;61722:44;::::0;7413:25:1;;;61722:44:0::1;::::0;::::1;::::0;61734:10:::1;::::0;61722:44:::1;::::0;7401:2:1;7386:18;61722:44:0::1;;;;;;;;61583:191:::0;;:::o;62098:106::-;56859:16;;;;56845:10;:30;;:53;;-1:-1:-1;56893:5:0;;;;56879:10;:19;56845:53;:88;;;-1:-1:-1;56916:17:0;;;;56902:10;:31;56845:88;56837:126;;;;;;;14234:2:1;56837:126:0;;;14216:21:1;14273:2;14253:18;;;14246:30;14312:27;14292:18;;;14285:55;14357:18;;56837:126:0;14206:175:1;56837:126:0;62181:15:::1;::::0;;62162:34;;::::1;62181:15;::::0;;::::1;62180:16;62162:34;::::0;;62098:106::o;51045:271::-;51114:14;;;;51100:10;:28;51092:94;;;;;;;10531:2:1;51092:94:0;;;10513:21:1;10570:2;10550:18;;;10543:30;10609:34;10589:18;;;10582:62;10680:23;10660:18;;;10653:51;10721:19;;51092:94:0;10503:243:1;51092:94:0;51215:5;;51222:14;;51202:35;;;51215:5;;;;5284:34:1;;51222:14:0;;;;5349:2:1;5334:18;;5327:43;51202:35:0;;5196:18:1;51202:35:0;;;;;;;51256:14;;;51248:5;:22;;;;;;51256:14;;;51248:22;;;;51281:27;;;51045:271::o;26211:295::-;26288:26;26317:84;26354:6;26317:84;;;;;;;;;;;;;;;;;:32;26327:7;819:10;21300:151;:::i;26317:32::-;:36;:84;:36;:84::i;:::-;26288:113;-1:-1:-1;26414:51:0;26423:7;819:10;26446:18;26414:8;:51::i;:::-;26476:22;26482:7;26491:6;26476:5;:22::i;48151:128::-;48247:14;;;48220:7;48247:14;;;:7;:14;;;;;45619;48247:24;48240:31;48151:128;-1:-1:-1;;48151:128:0:o;55910:47::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55910:47:0;;-1:-1:-1;55910:47:0:o;65452:181::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;65550:75:::1;65586:12;65601:10;65613:11;65550:27;:75::i;:::-;65452:181:::0;;:::o;59430:804::-;59585:28;53270:1;53876:7;;:19;;53868:63;;;;;;;19455:2:1;53868:63:0;;;19437:21:1;19494:2;19474:18;;;19467:30;19533:33;19513:18;;;19506:61;19584:18;;53868:63:0;19427:181:1;53868:63:0;53270:1;54009:7;:18;57298:28:::1;::::0;::::1;;::::0;;;:13:::1;:28;::::0;;;;;59554:20;;57298:28:::1;;57290:58;;;::::0;::::1;::::0;;13485:2:1;57290:58:0::1;::::0;::::1;13467:21:1::0;13524:2;13504:18;;;13497:30;13563:19;13543:18;;;13536:47;13600:18;;57290:58:0::1;13457:167:1::0;57290:58:0::1;59635:15:::2;::::0;::::2;;59634:16;:49:::0;::::2;;;-1:-1:-1::0;59654:29:0::2;::::0;::::2;;::::0;;;:7:::2;:29;::::0;;;;;::::2;;59634:49;59626:78;;;::::0;::::2;::::0;;16801:2:1;59626:78:0::2;::::0;::::2;16783:21:1::0;16840:2;16820:18;;;16813:30;16879:18;16859;;;16852:46;16915:18;;59626:78:0::2;16773:166:1::0;59626:78:0::2;59752:94;59784:20;59806:10;59826:4;59833:12;59752:31;:94::i;:::-;59924:12;59901:35;;59952:24;59965:10;59952:12;:24::i;:::-;59947:161;;60042:31;::::0;::::2;;::::0;;;:9:::2;:31;::::0;;;;:34;56424:3:::2;::::0;60019:57:::2;::::0;:20;:57:::2;:::i;:::-;60018:77;;;;:::i;:::-;59993:103;::::0;;::::2;:::i;:::-;;;59947:161;60180:46;60193:10;60205:20;60180:12;:46::i;19694:87::-:0;19733:13;19766:7;19759:14;;;;;:::i;63307:358::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;63391:28:::1;::::0;::::1;63383:62;;;::::0;::::1;::::0;;12421:2:1;63383:62:0::1;::::0;::::1;12403:21:1::0;12460:2;12440:18;;;12433:30;12499:23;12479:18;;;12472:51;12540:18;;63383:62:0::1;12393:171:1::0;63383:62:0::1;63466:23;::::0;::::1;;::::0;;;:7:::1;:23;::::0;;;;;::::1;;:32;63458:67;;;::::0;::::1;::::0;;16102:2:1;63458:67:0::1;::::0;::::1;16084:21:1::0;16141:2;16121:18;;;16114:30;16180:24;16160:18;;;16153:52;16222:18;;63458:67:0::1;16074:172:1::0;63458:67:0::1;63536:23;::::0;::::1;;::::0;;;:7:::1;:23;::::0;;;;;;;:30;;;::::1;63562:4;63536:30:::0;;::::1;::::0;;;63578:13:::1;:34:::0;;;;::::1;::::0;;;;;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;63630:27;;4964:74:1;;;63630:27:0::1;::::0;4937:18:1;63630:27:0::1;4919:125:1::0;23730:269:0;23823:4;23840:129;819:10;23863:7;23872:96;23911:15;23872:96;;;;;;;;;;;;;;;;;819:10;23872:25;;;;:11;:25;;;;;;;;;:34;;;;;;;;;;;;:38;:96::i;64559:224::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;64700:75:::1;::::0;;;;::::1;::::0;;;;;::::1;::::0;;::::1;::::0;;;:31:::1;::::0;::::1;-1:-1:-1::0;64700:31:0;;;:9:::1;:31:::0;;;;;;;:75:::1;::::0;::::1;;:::i;:::-;;64559:224:::0;;;:::o;21062:175::-;21148:4;21165:42;819:10;21189:9;21200:6;21165:9;:42::i;65663:274::-;56705:16;;65796:4;;65802:12;;56705:16;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;65828:12:::1;65842:19:::0;65865:3:::1;:8;;65880:6;65888:5;;65865:29;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;65827:67:0;;-1:-1:-1;65827:67:0;-1:-1:-1;;;56781:1:0::1;65663:274:::0;;;;;;;:::o;64951:229::-;56705:16;;;;56691:10;:30;;:53;;-1:-1:-1;56739:5:0;;;;56725:10;:19;56691:53;56683:87;;;;;;;11313:2:1;56683:87:0;;;11295:21:1;11352:2;11332:18;;;11325:30;11391:23;11371:18;;;11364:51;11432:18;;56683:87:0;11285:171:1;56683:87:0;65035:26:::1;::::0;::::1;65027:60;;;::::0;::::1;::::0;;12421:2:1;65027:60:0::1;::::0;::::1;12403:21:1::0;12460:2;12440:18;;;12433:30;12499:23;12479:18;;;12472:51;12540:18;;65027:60:0::1;12393:171:1::0;65027:60:0::1;65098:16;:31:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;65147:25:::1;::::0;4964:74:1;;;65147:25:0::1;::::0;4952:2:1;4937:18;65147:25:0::1;4919:125:1::0;58575:113:0;58625:16;58661:19;58654:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58575:113;:::o;47440:645::-;47684:8;47665:15;:27;;47657:69;;;;;;;13127:2:1;47657:69:0;;;13109:21:1;13166:2;13146:18;;;13139:30;13205:31;13185:18;;;13178:59;13254:18;;47657:69:0;13099:179:1;47657:69:0;47739:18;47781:16;47799:5;47806:7;47815:5;47822:16;47832:5;47822:9;:16::i;:::-;47770:79;;;;;;7736:25:1;;;;7780:42;7858:15;;;7838:18;;;7831:43;7910:15;;;;7890:18;;;7883:43;7942:18;;;7935:34;7985:19;;;7978:35;8029:19;;;8022:35;;;7708:19;;47770:79:0;;;;;;;;;;;;47760:90;;;;;;47739:111;;47863:12;47878:28;47895:10;47878:16;:28::i;:::-;47863:43;;47919:14;47936:28;47950:4;47956:1;47959;47962;47936:13;:28::i;:::-;47919:45;;47993:5;47983:15;;:6;:15;;;47975:58;;;;;;;15407:2:1;47975:58:0;;;15389:21:1;15446:2;15426:18;;;15419:30;15485:32;15465:18;;;15458:60;15535:18;;47975:58:0;15379:180:1;47975:58:0;48046:31;48055:5;48062:7;48071:5;48046:8;:31::i;:::-;47646:439;;;47440:645;;;;;;;:::o;56207:30::-;;;;;;;;;;;;61851:155;57040:10;57032:19;;;;:7;:19;;;;;;;;57024:44;;;;;;;17954:2:1;57024:44:0;;;17936:21:1;17993:2;17973:18;;;17966:30;18032:14;18012:18;;;18005:42;18064:18;;57024:44:0;17926:162:1;57024:44:0;61920:31:::1;61932:10;61944:6;61920:11;:31::i;:::-;61967;::::0;7413:25:1;;;61979:10:0::1;::::0;61967:31:::1;::::0;7401:2:1;7386:18;61967:31:0::1;7368:76:1::0;25309:378:0;25393:21;;;25385:65;;;;;;;19815:2:1;25385:65:0;;;19797:21:1;19854:2;19834:18;;;19827:30;19893:33;19873:18;;;19866:61;19944:18;;25385:65:0;19787:181:1;25385:65:0;25540:12;;:24;;25557:6;25540:16;:24::i;:::-;25525:12;:39;25596:18;;;:9;:18;;;;;;;;;;;:30;;25619:6;25596:22;:30::i;:::-;25575:18;;;:9;:18;;;;;;;;;;;:51;;;;25642:37;;7413:25:1;;;25575:18:0;;:9;;25642:37;;7386:18:1;25642:37:0;7368:76:1;1961:181:0;2019:7;;2051:5;2055:1;2051;:5;:::i;:::-;2039:17;;2080:1;2075;:6;;2067:46;;;;;;;12771:2:1;2067:46:0;;;12753:21:1;12810:2;12790:18;;;12783:30;12849:29;12829:18;;;12822:57;12896:18;;2067:46:0;12743:177:1;2067:46:0;2133:1;1961:181;-1:-1:-1;;;1961:181:0:o;58696:182::-;58805:16;;58765:4;;58805:16;58790:31;;;58805:16;;58790:31;;:55;;-1:-1:-1;58840:5:0;;;58825:20;;;58840:5;;58825:20;58790:55;:79;;;-1:-1:-1;;58849:20:0;;;;;;:7;:20;;;;;;;;;58696:182::o;49545:361::-;49740:45;;;49729:10;5976:55:1;;;49740:45:0;;;5958:74:1;6048:18;;;;6041:34;;;49740:45:0;;;;;;;;;;5931:18:1;;;;49740:45:0;;;;;;;;;;;;;49729:57;;-1:-1:-1;;;;49729:10:0;;;;:57;;49740:45;49729:57;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49693:93;;;;49805:7;:57;;;;-1:-1:-1;49817:11:0;;:16;;:44;;;49848:4;49837:24;;;;;;;;;;;;:::i;:::-;49797:101;;;;;;;10171:2:1;49797:101:0;;;10153:21:1;10210:2;10190:18;;;10183:30;10249:33;10229:18;;;10222:61;10300:18;;49797:101:0;10143:181:1;49797:101:0;49615:291;;49545:361;;;:::o;27698:346::-;27800:19;;;27792:68;;;;;;;18295:2:1;27792:68:0;;;18277:21:1;18334:2;18314:18;;;18307:30;18373:34;18353:18;;;18346:62;18444:6;18424:18;;;18417:34;18468:19;;27792:68:0;18267:226:1;27792:68:0;27879:21;;;27871:68;;;;;;;11663:2:1;27871:68:0;;;11645:21:1;11702:2;11682:18;;;11675:30;11741:34;11721:18;;;11714:62;11812:4;11792:18;;;11785:32;11834:19;;27871:68:0;11635:224:1;27871:68:0;27952:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;28004:32;;7413:25:1;;;28004:32:0;;7386:18:1;28004:32:0;;;;;;;;27698:346;;;:::o;24489:539::-;24595:20;;;24587:70;;;;;;;17548:2:1;24587:70:0;;;17530:21:1;17587:2;17567:18;;;17560:30;17626:34;17606:18;;;17599:62;17697:7;17677:18;;;17670:35;17722:19;;24587:70:0;17520:227:1;24587:70:0;24676:23;;;24668:71;;;;;;;9767:2:1;24668:71:0;;;9749:21:1;9806:2;9786:18;;;9779:30;9845:34;9825:18;;;9818:62;9916:5;9896:18;;;9889:33;9939:19;;24668:71:0;9739:225:1;24668:71:0;24832;24854:6;24832:71;;;;;;;;;;;;;;;;;:17;;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;24812:17;;;;:9;:17;;;;;;;;;;;:91;;;;24937:20;;;;;;;:32;;24962:6;24937:24;:32::i;:::-;24914:20;;;;:9;:20;;;;;;;;;;;;:55;;;;24985:35;7413:25:1;;;24914:20:0;;24985:35;;;;;;7386:18:1;24985:35:0;7368:76:1;2890:192:0;2976:7;3012:12;3004:6;;;;2996:29;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3036:9:0;3048:5;3052:1;3048;:5;:::i;:::-;3036:17;2890:192;-1:-1:-1;;;;;2890:192:0:o;26840:418::-;26924:21;;;26916:67;;;;;;;17146:2:1;26916:67:0;;;17128:21:1;17185:2;17165:18;;;17158:30;17224:34;17204:18;;;17197:62;17295:3;17275:18;;;17268:31;17316:19;;26916:67:0;17118:223:1;26916:67:0;27079:68;27102:6;27079:68;;;;;;;;;;;;;;;;;:18;;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;27058:18;;;:9;:18;;;;;;;;;;:89;27173:12;;:24;;27190:6;27173:16;:24::i;:::-;27158:12;:39;27213:37;;7413:25:1;;;27239:1:0;;27213:37;;;;;;7401:2:1;7386:18;27213:37:0;7368:76:1;58886:160:0;58952:4;58977:28;58993:11;58977:15;:28::i;:::-;:60;;;-1:-1:-1;;59009:28:0;;;;;;:15;:28;;;;;;;;;58886:160::o;43370:281::-;43423:7;43464:16;43447:13;:33;43443:201;;;-1:-1:-1;43504:24:0;;43370:281::o;43443:201::-;-1:-1:-1;43840:73:0;;;43590:10;43840:73;;;;8327:25:1;;;;43602:12:0;8368:18:1;;;8361:34;43616:15:0;8411:18:1;;;8404:34;43884:13:0;8454:18:1;;;8447:34;43907:4:0;8497:19:1;;;;8490:84;;;;43840:73:0;;;;;;;;;;8299:19:1;;;;43840:73:0;;;43830:84;;;;;;48409:115::o;59138:177::-;59247:8;;59237:6;59221:13;20647:12;;;20567:100;59221:13;:22;;;;:::i;:::-;:34;;59213:55;;;;;;;15766:2:1;59213:55:0;;;15748:21:1;15805:1;15785:18;;;15778:29;15843:10;15823:18;;;15816:38;15871:18;;59213:55:0;15738:157:1;59213:55:0;59279:28;59291:7;59300:6;59279:11;:28::i;49914:402::-;50139:51;;;50128:10;5662:15:1;;;50139:51:0;;;5644:34:1;5714:15;;;5694:18;;;5687:43;5746:18;;;;5739:34;;;50139:51:0;;;;;;;;;;5556:18:1;;;;50139:51:0;;;;;;;;;;;;;50128:63;;-1:-1:-1;;;;50128:10:0;;;;:63;;50139:51;50128:63;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50092:99;;;;50210:7;:57;;;;-1:-1:-1;50222:11:0;;:16;;:44;;;50253:4;50242:24;;;;;;;;;;;;:::i;:::-;50202:106;;;;;;;19050:2:1;50202:106:0;;;19032:21:1;19089:2;19069:18;;;19062:30;19128:34;19108:18;;;19101:62;19199:6;19179:18;;;19172:34;19223:19;;50202:106:0;19022:226:1;50202:106:0;50002:314;;49914:402;;;;:::o;48771:207::-;48892:14;;;48831:15;48892:14;;;:7;:14;;;;;45619;;45756:1;45738:19;;;;45619:14;48953:17;48848:130;48771:207;;;:::o;44564:167::-;44641:7;44668:55;44690:20;:18;:20::i;:::-;44712:10;40272:57;;4639:66:1;40272:57:0;;;4627:79:1;4722:11;;;4715:27;;;4758:12;;;4751:28;;;40235:7:0;;4795:12:1;;40272:57:0;;;;;;;;;;;;40262:68;;;;;;40255:75;;40142:196;;;;;38944:279;39072:7;39093:17;39112:18;39134:25;39145:4;39151:1;39154;39157;39134:10;:25::i;:::-;39092:67;;;;39170:18;39182:5;39170:11;:18::i;:::-;-1:-1:-1;39206:9:0;38944:279;-1:-1:-1;;;;;38944:279:0:o;2417:136::-;2475:7;2502:43;2506:1;2509;2502:43;;;;;;;;;;;;;;;;;:3;:43::i;37173:1632::-;37304:7;;38238:66;38225:79;;38221:163;;;-1:-1:-1;38337:1:0;;-1:-1:-1;38341:30:0;38321:51;;38221:163;38398:1;:7;;38403:2;38398:7;;:18;;;;;38409:1;:7;;38414:2;38409:7;;38398:18;38394:102;;;-1:-1:-1;38449:1:0;;-1:-1:-1;38453:30:0;38433:51;;38394:102;38610:24;;;38593:14;38610:24;;;;;;;;;8812:25:1;;;8885:4;8873:17;;8853:18;;;8846:45;;;;8907:18;;;8900:34;;;8950:18;;;8943:34;;;38610:24:0;;8784:19:1;;38610:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;38610:24:0;;;;;;-1:-1:-1;;38649:20:0;;;38645:103;;38702:1;38706:29;38686:50;;;;;;;38645:103;38768:6;38776:20;;-1:-1:-1;37173:1632:0;-1:-1:-1;;;;;37173:1632:0:o;31835:643::-;31913:20;31904:5;:29;;;;;;;;:::i;:::-;;31900:571;;;31835:643;:::o;31900:571::-;32011:29;32002:5;:38;;;;;;;;:::i;:::-;;31998:473;;;32057:34;;;;;9414:2:1;32057:34:0;;;9396:21:1;9453:2;9433:18;;;9426:30;9492:26;9472:18;;;9465:54;9536:18;;32057:34:0;9386:174:1;31998:473:0;32122:35;32113:5;:44;;;;;;;;:::i;:::-;;32109:362;;;32174:41;;;;;10953:2:1;32174:41:0;;;10935:21:1;10992:2;10972:18;;;10965:30;11031:33;11011:18;;;11004:61;11082:18;;32174:41:0;10925:181:1;32109:362:0;32246:30;32237:5;:39;;;;;;;;:::i;:::-;;32233:238;;;32293:44;;;;;13831:2:1;32293:44:0;;;13813:21:1;13870:2;13850:18;;;13843:30;13909:34;13889:18;;;13882:62;13980:4;13960:18;;;13953:32;14002:19;;32293:44:0;13803:224:1;32233:238:0;32368:30;32359:5;:39;;;;;;;;:::i;:::-;;32355:116;;;32415:44;;;;;14588:2:1;32415:44:0;;;14570:21:1;14627:2;14607:18;;;14600:30;14666:34;14646:18;;;14639:62;14737:4;14717:18;;;14710:32;14759:19;;32415:44:0;14560:224:1;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:196:1;82:20;;142:42;131:54;;121:65;;111:2;;200:1;197;190:12;111:2;63:147;;;:::o;215:186::-;274:6;327:2;315:9;306:7;302:23;298:32;295:2;;;343:1;340;333:12;295:2;366:29;385:9;366:29;:::i;406:260::-;474:6;482;535:2;523:9;514:7;510:23;506:32;503:2;;;551:1;548;541:12;503:2;574:29;593:9;574:29;:::i;:::-;564:39;;622:38;656:2;645:9;641:18;622:38;:::i;:::-;612:48;;493:173;;;;;:::o;671:328::-;748:6;756;764;817:2;805:9;796:7;792:23;788:32;785:2;;;833:1;830;823:12;785:2;856:29;875:9;856:29;:::i;:::-;846:39;;904:38;938:2;927:9;923:18;904:38;:::i;:::-;894:48;;989:2;978:9;974:18;961:32;951:42;;775:224;;;;;:::o;1004:693::-;1115:6;1123;1131;1139;1147;1155;1163;1216:3;1204:9;1195:7;1191:23;1187:33;1184:2;;;1233:1;1230;1223:12;1184:2;1256:29;1275:9;1256:29;:::i;:::-;1246:39;;1304:38;1338:2;1327:9;1323:18;1304:38;:::i;:::-;1294:48;;1389:2;1378:9;1374:18;1361:32;1351:42;;1440:2;1429:9;1425:18;1412:32;1402:42;;1494:3;1483:9;1479:19;1466:33;1539:4;1532:5;1528:16;1521:5;1518:27;1508:2;;1559:1;1556;1549:12;1508:2;1174:523;;;;-1:-1:-1;1174:523:1;;;;1582:5;1634:3;1619:19;;1606:33;;-1:-1:-1;1686:3:1;1671:19;;;1658:33;;1174:523;-1:-1:-1;;1174:523:1:o;1702:254::-;1770:6;1778;1831:2;1819:9;1810:7;1806:23;1802:32;1799:2;;;1847:1;1844;1837:12;1799:2;1870:29;1889:9;1870:29;:::i;:::-;1860:39;1946:2;1931:18;;;;1918:32;;-1:-1:-1;;;1789:167:1:o;1961:733::-;2049:6;2057;2065;2073;2126:2;2114:9;2105:7;2101:23;2097:32;2094:2;;;2142:1;2139;2132:12;2094:2;2165:29;2184:9;2165:29;:::i;:::-;2155:39;;2241:2;2230:9;2226:18;2213:32;2203:42;;2296:2;2285:9;2281:18;2268:32;2319:18;2360:2;2352:6;2349:14;2346:2;;;2376:1;2373;2366:12;2346:2;2414:6;2403:9;2399:22;2389:32;;2459:7;2452:4;2448:2;2444:13;2440:27;2430:2;;2481:1;2478;2471:12;2430:2;2521;2508:16;2547:2;2539:6;2536:14;2533:2;;;2563:1;2560;2553:12;2533:2;2608:7;2603:2;2594:6;2590:2;2586:15;2582:24;2579:37;2576:2;;;2629:1;2626;2619:12;2576:2;2084:610;;;;-1:-1:-1;;2660:2:1;2652:11;;-1:-1:-1;;;2084:610:1:o;2699:322::-;2776:6;2784;2792;2845:2;2833:9;2824:7;2820:23;2816:32;2813:2;;;2861:1;2858;2851:12;2813:2;2884:29;2903:9;2884:29;:::i;:::-;2874:39;2960:2;2945:18;;2932:32;;-1:-1:-1;3011:2:1;2996:18;;;2983:32;;2803:218;-1:-1:-1;;;2803:218:1:o;3026:277::-;3093:6;3146:2;3134:9;3125:7;3121:23;3117:32;3114:2;;;3162:1;3159;3152:12;3114:2;3194:9;3188:16;3247:5;3240:13;3233:21;3226:5;3223:32;3213:2;;3269:1;3266;3259:12;3308:180;3367:6;3420:2;3408:9;3399:7;3395:23;3391:32;3388:2;;;3436:1;3433;3426:12;3388:2;-1:-1:-1;3459:23:1;;3378:110;-1:-1:-1;3378:110:1:o;3493:316::-;3534:3;3572:5;3566:12;3599:6;3594:3;3587:19;3615:63;3671:6;3664:4;3659:3;3655:14;3648:4;3641:5;3637:16;3615:63;:::i;:::-;3723:2;3711:15;3728:66;3707:88;3698:98;;;;3798:4;3694:109;;3542:267;-1:-1:-1;;3542:267:1:o;3814:271::-;3997:6;3989;3984:3;3971:33;3953:3;4023:16;;4048:13;;;4023:16;3961:124;-1:-1:-1;3961:124:1:o;4090:274::-;4219:3;4257:6;4251:13;4273:53;4319:6;4314:3;4307:4;4299:6;4295:17;4273:53;:::i;:::-;4342:16;;;;;4227:137;-1:-1:-1;;4227:137:1:o;6086:681::-;6257:2;6309:21;;;6379:13;;6282:18;;;6401:22;;;6228:4;;6257:2;6480:15;;;;6454:2;6439:18;;;6228:4;6523:218;6537:6;6534:1;6531:13;6523:218;;;6602:13;;6617:42;6598:62;6586:75;;6716:15;;;;6681:12;;;;6559:1;6552:9;6523:218;;;-1:-1:-1;6758:3:1;;6237:530;-1:-1:-1;;;;;;6237:530:1:o;6964:298::-;7147:6;7140:14;7133:22;7122:9;7115:41;7192:2;7187;7176:9;7172:18;7165:30;7096:4;7212:44;7252:2;7241:9;7237:18;7229:6;7212:44;:::i;:::-;7204:52;7105:157;-1:-1:-1;;;;7105:157:1:o;8988:219::-;9137:2;9126:9;9119:21;9100:4;9157:44;9197:2;9186:9;9182:18;9174:6;9157:44;:::i;20344:128::-;20384:3;20415:1;20411:6;20408:1;20405:13;20402:2;;;20421:18;;:::i;:::-;-1:-1:-1;20457:9:1;;20392:80::o;20477:274::-;20517:1;20543;20533:2;;20578:77;20575:1;20568:88;20679:4;20676:1;20669:15;20707:4;20704:1;20697:15;20533:2;-1:-1:-1;20736:9:1;;20523:228::o;20756:::-;20796:7;20922:1;20854:66;20850:74;20847:1;20844:81;20839:1;20832:9;20825:17;20821:105;20818:2;;;20929:18;;:::i;:::-;-1:-1:-1;20969:9:1;;20808:176::o;20989:125::-;21029:4;21057:1;21054;21051:8;21048:2;;;21062:18;;:::i;:::-;-1:-1:-1;21099:9:1;;21038:76::o;21119:258::-;21191:1;21201:113;21215:6;21212:1;21209:13;21201:113;;;21291:11;;;21285:18;21272:11;;;21265:39;21237:2;21230:10;21201:113;;;21332:6;21329:1;21326:13;21323:2;;;-1:-1:-1;;21367:1:1;21349:16;;21342:27;21172:205::o;21382:437::-;21461:1;21457:12;;;;21504;;;21525:2;;21579:4;21571:6;21567:17;21557:27;;21525:2;21632;21624:6;21621:14;21601:18;21598:38;21595:2;;;21669:77;21666:1;21659:88;21770:4;21767:1;21760:15;21798:4;21795:1;21788:15;21824:195;21863:3;21894:66;21887:5;21884:77;21881:2;;;21964:18;;:::i;:::-;-1:-1:-1;22011:1:1;22000:13;;21871:148::o;22024:184::-;22076:77;22073:1;22066:88;22173:4;22170:1;22163:15;22197:4;22194:1;22187:15;22213:184;22265:77;22262:1;22255:88;22362:4;22359:1;22352:15;22386:4;22383:1;22376:15;22402:184;22454:77;22451:1;22444:88;22551:4;22548:1;22541:15;22575:4;22572:1;22565:15

ipfs://d909f34807fcfdc459d542eb88dca6cc7e855d3cf8a7ecffc61e54e2e8ef2aa5