Contract 0x83A3451A569e941E2ddB79942F404c126a1B56Bf

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;

import "@indexed-finance/proxies/contracts/interfaces/IDelegateCallProxyManager.sol";


interface IPoolFactory {
/* ========== Events ========== */

  event NewPool(address pool, address controller, bytes32 implementationID);

/* ========== Mutative ========== */

  function approvePoolController(address controller) external;

  function disapprovePoolController(address controller) external;

  function deployPool(bytes32 implementationID, bytes32 controllerSalt) external returns (address);

/* ========== Views ========== */

  function proxyManager() external view returns (IDelegateCallProxyManager);

  function isApprovedController(address) external view returns (bool);

  function getPoolImplementationID(address) external view returns (bytes32);

  function isRecognizedPool(address pool) external view returns (bool);

  function computePoolAddress(
    bytes32 implementationID,
    address controller,
    bytes32 controllerSalt
  ) external view returns (address);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;


/**
 * @dev Contract that manages deployment and upgrades of delegatecall proxies.
 *
 * An implementation identifier can be created on the proxy manager which is
 * used to specify the logic address for a particular contract type, and to
 * upgrade the implementation as needed.
 *
 * A one-to-one proxy is a single proxy contract with an upgradeable implementation
 * address.
 *
 * A many-to-one proxy is a single upgradeable implementation address that may be
 * used by many proxy contracts.
 */
interface IDelegateCallProxyManager {
/* ==========  Events  ========== */

  event DeploymentApprovalGranted(address deployer);
  event DeploymentApprovalRevoked(address deployer);

  event ManyToOne_ImplementationCreated(
    bytes32 implementationID,
    address implementationAddress
  );

  event ManyToOne_ImplementationUpdated(
    bytes32 implementationID,
    address implementationAddress
  );

  event ManyToOne_ProxyDeployed(
    bytes32 implementationID,
    address proxyAddress
  );

  event OneToOne_ProxyDeployed(
    address proxyAddress,
    address implementationAddress
  );

  event OneToOne_ImplementationUpdated(
    address proxyAddress,
    address implementationAddress
  );

/* ==========  Controls  ========== */

  /**
   * @dev Allows `deployer` to deploy many-to-one proxies.
   */
  function approveDeployer(address deployer) external;

  /**
   * @dev Prevents `deployer` from deploying many-to-one proxies.
   */
  function revokeDeployerApproval(address deployer) external;

/* ==========  Implementation Management  ========== */

  /**
   * @dev Creates a many-to-one proxy relationship.
   *
   * Deploys an implementation holder contract which stores the
   * implementation address for many proxies. The implementation
   * address can be updated on the holder to change the runtime
   * code used by all its proxies.
   *
   * @param implementationID ID for the implementation, used to identify the
   * proxies that use it. Also used as the salt in the create2 call when
   * deploying the implementation holder contract.
   * @param implementation Address with the runtime code the proxies
   * should use.
   */
  function createManyToOneProxyRelationship(
    bytes32 implementationID,
    address implementation
  ) external;

  /**
   * @dev Lock the current implementation for `proxyAddress` so that it can never be upgraded again.
   */
  function lockImplementationManyToOne(bytes32 implementationID) external;

  /**
   * @dev Lock the current implementation for `proxyAddress` so that it can never be upgraded again.
   */
  function lockImplementationOneToOne(address proxyAddress) external;

  /**
   * @dev Updates the implementation address for a many-to-one
   * proxy relationship.
   *
   * @param implementationID Identifier for the implementation.
   * @param implementation Address with the runtime code the proxies
   * should use.
   */
  function setImplementationAddressManyToOne(
    bytes32 implementationID,
    address implementation
  ) external;

  /**
   * @dev Updates the implementation address for a one-to-one proxy.
   *
   * Note: This could work for many-to-one as well if the caller
   * provides the implementation holder address in place of the
   * proxy address, as they use the same access control and update
   * mechanism.
   *
   * @param proxyAddress Address of the deployed proxy
   * @param implementation Address with the runtime code for
   * the proxy to use.
   */
  function setImplementationAddressOneToOne(
    address proxyAddress,
    address implementation
  ) external;

/* ==========  Proxy Deployment  ========== */

  /**
   * @dev Deploy a proxy contract with a one-to-one relationship
   * with its implementation.
   *
   * The proxy will have its own implementation address which can
   * be updated by the proxy manager.
   *
   * @param suppliedSalt Salt provided by the account requesting deployment.
   * @param implementation Address of the contract with the runtime
   * code that the proxy should use.
   */
  function deployProxyOneToOne(
    bytes32 suppliedSalt,
    address implementation
  ) external returns(address proxyAddress);

  /**
   * @dev Deploy a proxy with a many-to-one relationship with its implemenation.
   *
   * The proxy will call the implementation holder for every transaction to
   * determine the address to use in calls.
   *
   * @param implementationID Identifier for the proxy's implementation.
   * @param suppliedSalt Salt provided by the account requesting deployment.
   */
  function deployProxyManyToOne(
    bytes32 implementationID,
    bytes32 suppliedSalt
  ) external returns(address proxyAddress);

/* ==========  Queries  ========== */

  /**
   * @dev Returns a boolean stating whether `implementationID` is locked.
   */
  function isImplementationLocked(bytes32 implementationID) external view returns (bool);

  /**
   * @dev Returns a boolean stating whether `proxyAddress` is locked.
   */
  function isImplementationLocked(address proxyAddress) external view returns (bool);

  /**
   * @dev Returns a boolean stating whether `deployer` is allowed to deploy many-to-one
   * proxies.
   */
  function isApprovedDeployer(address deployer) external view returns (bool);

  /**
   * @dev Queries the temporary storage value `_implementationHolder`.
   * This is used in the constructor of the many-to-one proxy contract
   * so that the create2 address is static (adding constructor arguments
   * would change the codehash) and the implementation holder can be
   * stored as a constant.
   */
  function getImplementationHolder() external view returns (address);

  /**
   * @dev Returns the address of the implementation holder contract
   * for `implementationID`.
   */
  function getImplementationHolder(bytes32 implementationID) external view returns (address);

  /**
   * @dev Computes the create2 address for a one-to-one proxy requested
   * by `originator` using `suppliedSalt`.
   *
   * @param originator Address of the account requesting deployment.
   * @param suppliedSalt Salt provided by the account requesting deployment.
   */
  function computeProxyAddressOneToOne(
    address originator,
    bytes32 suppliedSalt
  ) external view returns (address);

  /**
   * @dev Computes the create2 address for a many-to-one proxy for the
   * implementation `implementationID` requested by `originator` using
   * `suppliedSalt`.
   *
   * @param originator Address of the account requesting deployment.
   * @param implementationID The identifier for the contract implementation.
   * @param suppliedSalt Salt provided by the account requesting deployment.
  */
  function computeProxyAddressManyToOne(
    address originator,
    bytes32 implementationID,
    bytes32 suppliedSalt
  ) external view returns (address);

  /**
   * @dev Computes the create2 address of the implementation holder
   * for `implementationID`.
   *
   * @param implementationID The identifier for the contract implementation.
  */
  function computeHolderAddressManyToOne(bytes32 implementationID) external view returns (address);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

/* ========== External Inheritance ========== */
import "@openzeppelin/contracts/access/Ownable.sol";

/* ========== External Interfaces ========== */
import "@indexed-finance/proxies/contracts/interfaces/IDelegateCallProxyManager.sol";

/* ========== External Libraries ========== */
import "@indexed-finance/proxies/contracts/SaltyLib.sol";

/* ========== Internal Interfaces ========== */
import "./interfaces/IPoolFactory.sol";


/**
 * @title PoolFactory
 * @author d1ll0n
 */
contract PoolFactory is Ownable, IPoolFactory {
/* ==========  Constants  ========== */

  // Address of the proxy manager contract.
  IDelegateCallProxyManager public override immutable proxyManager;

/* ==========  Events  ========== */

  /** @dev Emitted when a pool is deployed. */
  event NewPool(address pool, address controller, bytes32 implementationID);

/* ==========  Storage  ========== */

  mapping(address => bool) public override isApprovedController;
  mapping(address => bytes32) public override getPoolImplementationID;

/* ==========  Modifiers  ========== */

  modifier onlyApproved {
    require(isApprovedController[msg.sender], "ERR_NOT_APPROVED");
    _;
  }

/* ==========  Constructor  ========== */

  constructor(IDelegateCallProxyManager proxyManager_) public Ownable() {
    proxyManager = proxyManager_;
  }

/* ==========  Controller Approval  ========== */

  /** @dev Approves `controller` to deploy pools. */
  function approvePoolController(address controller) external override onlyOwner {
    isApprovedController[controller] = true;
  }

  /** @dev Removes the ability of `controller` to deploy pools. */
  function disapprovePoolController(address controller) external override onlyOwner {
    isApprovedController[controller] = false;
  }

/* ==========  Pool Deployment  ========== */

  /**
   * @dev Deploys a pool using an implementation ID provided by the controller.
   *
   * Note: To support future interfaces, this does not initialize or
   * configure the pool, this must be executed by the controller.
   *
   * Note: Must be called by an approved controller.
   *
   * @param implementationID Implementation ID for the pool
   * @param controllerSalt Create2 salt provided by the deployer
   */
  function deployPool(bytes32 implementationID, bytes32 controllerSalt)
    external
    override
    onlyApproved
    returns (address poolAddress)
  {
    bytes32 suppliedSalt = keccak256(abi.encodePacked(msg.sender, controllerSalt));
    poolAddress = proxyManager.deployProxyManyToOne(implementationID, suppliedSalt);
    getPoolImplementationID[poolAddress] = implementationID;
    emit NewPool(poolAddress, msg.sender, implementationID);
  }

/* ==========  Queries  ========== */

  /**
   * @dev Checks if an address is a pool that was deployed by the factory.
   */
  function isRecognizedPool(address pool) external view override returns (bool) {
    return getPoolImplementationID[pool] != bytes32(0);
  }

  /**
   * @dev Compute the create2 address for a pool deployed by an approved controller.
   */
  function computePoolAddress(bytes32 implementationID, address controller, bytes32 controllerSalt)
    public
    view
    override
    returns (address)
  {
    bytes32 suppliedSalt = keccak256(abi.encodePacked(controller, controllerSalt));
    return SaltyLib.computeProxyAddressManyToOne(
      address(proxyManager),
      address(this),
      implementationID,
      suppliedSalt
    );
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "../GSN/Context.sol";
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/*
 * @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 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;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;

/* ---  External Libraries  --- */
import { Create2 } from "@openzeppelin/contracts/utils/Create2.sol";

/* ---  Proxy Contracts  --- */
import { CodeHashes } from "./CodeHashes.sol";


/**
 * @dev Library for computing create2 salts and addresses for proxies
 * deployed by `DelegateCallProxyManager`.
 *
 * Because the proxy factory is meant to be used by multiple contracts,
 * we use a salt derivation pattern that includes the address of the
 * contract that requested the proxy deployment, a salt provided by that
 * contract and the implementation ID used (for many-to-one proxies only).
 */
library SaltyLib {
/* ---  Salt Derivation  --- */

  /**
   * @dev Derives the create2 salt for a many-to-one proxy.
   *
   * Many different contracts in the Indexed framework may use the
   * same implementation contract, and they all use the same init
   * code, so we derive the actual create2 salt from a combination
   * of the implementation ID, the address of the account requesting
   * deployment and the user-supplied salt.
   *
   * @param originator Address of the account requesting deployment.
   * @param implementationID The identifier for the contract implementation.
   * @param suppliedSalt Salt provided by the account requesting deployment.
   */
  function deriveManyToOneSalt(
    address originator,
    bytes32 implementationID,
    bytes32 suppliedSalt
  )
    internal
    pure
    returns (bytes32)
  {
    return keccak256(
      abi.encodePacked(
        originator,
        implementationID,
        suppliedSalt
      )
    );
  }

  /**
   * @dev Derives the create2 salt for a one-to-one proxy.
   *
   * @param originator Address of the account requesting deployment.
   * @param suppliedSalt Salt provided by the account requesting deployment.
   */
  function deriveOneToOneSalt(
    address originator,
    bytes32 suppliedSalt
  )
    internal
    pure
    returns (bytes32)
  {
    return keccak256(abi.encodePacked(originator, suppliedSalt));
  }

/* ---  Address Derivation  --- */

  /**
   * @dev Computes the create2 address for a one-to-one proxy deployed
   * by `deployer` (the factory) when requested by `originator` using
   * `suppliedSalt`.
   *
   * @param deployer Address of the proxy factory.
   * @param originator Address of the account requesting deployment.
   * @param suppliedSalt Salt provided by the account requesting deployment.
   */
  function computeProxyAddressOneToOne(
    address deployer,
    address originator,
    bytes32 suppliedSalt
  )
    internal
    pure
    returns (address)
  {
    bytes32 salt = deriveOneToOneSalt(originator, suppliedSalt);
    return Create2.computeAddress(salt, CodeHashes.ONE_TO_ONE_CODEHASH, deployer);
  }

  /**
   * @dev Computes the create2 address for a many-to-one proxy for the
   * implementation `implementationID` deployed by `deployer` (the factory)
   * when requested by `originator` using `suppliedSalt`.
   *
   * @param deployer Address of the proxy factory.
   * @param originator Address of the account requesting deployment.
   * @param implementationID The identifier for the contract implementation.
   * @param suppliedSalt Salt provided by the account requesting deployment.
  */
  function computeProxyAddressManyToOne(
    address deployer,
    address originator,
    bytes32 implementationID,
    bytes32 suppliedSalt
  )
    internal
    pure
    returns (address)
  {
    bytes32 salt = deriveManyToOneSalt(
      originator,
      implementationID,
      suppliedSalt
    );
    return Create2.computeAddress(salt, CodeHashes.MANY_TO_ONE_CODEHASH, deployer);
  }

  /**
   * @dev Computes the create2 address of the implementation holder
   * for `implementationID`.
   *
   * @param deployer Address of the proxy factory.
   * @param implementationID The identifier for the contract implementation.
  */
  function computeHolderAddressManyToOne(
    address deployer,
    bytes32 implementationID
  )
    internal
    pure
    returns (address)
  {
    return Create2.computeAddress(
      implementationID,
      CodeHashes.IMPLEMENTATION_HOLDER_CODEHASH,
      deployer
    );
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) {
        address addr;
        require(address(this).balance >= amount, "Create2: insufficient balance");
        require(bytecode.length != 0, "Create2: bytecode length is zero");
        // solhint-disable-next-line no-inline-assembly
        assembly {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
        }
        require(addr != address(0), "Create2: Failed on deploy");
        return addr;
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) {
        bytes32 _data = keccak256(
            abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash)
        );
        return address(uint256(_data));
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;


/**
 * @dev Because we use the code hashes of the proxy contracts for proxy address
 * derivation, it is important that other packages have access to the correct
 * values when they import the salt library.
 */
library CodeHashes {
  bytes32 internal constant ONE_TO_ONE_CODEHASH = 0x63d9f7b5931b69188c8f6b806606f25892f1bb17b7f7e966fe3a32c04493aee4;
  bytes32 internal constant MANY_TO_ONE_CODEHASH = 0xa035ad05a1663db5bfd455b99cd7c6ac6bd49269738458eda140e0b78ed53f79;
  bytes32 internal constant IMPLEMENTATION_HOLDER_CODEHASH = 0x11c370493a726a0ffa93d42b399ad046f1b5a543b6e72f1a64f1488dc1c58f2c;
}

{
  "metadata": {
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IDelegateCallProxyManager","name":"proxyManager_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"},{"indexed":false,"internalType":"address","name":"controller","type":"address"},{"indexed":false,"internalType":"bytes32","name":"implementationID","type":"bytes32"}],"name":"NewPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"approvePoolController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"implementationID","type":"bytes32"},{"internalType":"address","name":"controller","type":"address"},{"internalType":"bytes32","name":"controllerSalt","type":"bytes32"}],"name":"computePoolAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"implementationID","type":"bytes32"},{"internalType":"bytes32","name":"controllerSalt","type":"bytes32"}],"name":"deployPool","outputs":[{"internalType":"address","name":"poolAddress","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"disapprovePoolController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"getPoolImplementationID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isApprovedController","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"isRecognizedPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxyManager","outputs":[{"internalType":"contract IDelegateCallProxyManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000592f70ce43a310d15ff59be1460f38ab6df3fe65

-----Decoded View---------------
Arg [0] : proxyManager_ (address): 0x592f70ce43a310d15ff59be1460f38ab6df3fe65

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000592f70ce43a310d15ff59be1460f38ab6df3fe65

577:2964:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2330:445;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2905:139;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1526:129::-;;;;;;:::i;:::-;;:::i;:::-;;1689:145:4;;;:::i;983:61:6:-;;;;;;:::i;:::-;;:::i;1066:77:4:-;;;:::i;712:64:6:-;;;:::i;3145:394::-;;;;;;:::i;:::-;;:::i;1726:133::-;;;;;;:::i;:::-;;:::i;1983:240:4:-;;;;;;:::i;:::-;;:::i;1048:67:6:-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2330:445::-;1218:10;2456:19;1197:32;;;:20;:32;;;;;;;;1189:61;;;;-1:-1:-1;;;1189:61:6;;;;;;;:::i;:::-;;;;;;;;;2485:20:::1;2535:10;2547:14;2518:44;;;;;;;;;:::i;:::-;;::::0;;-1:-1:-1;;2518:44:6;;::::1;::::0;;;;;;;2508:55;;2518:44:::1;2508:55:::0;;::::1;::::0;-1:-1:-1;;;2583:65:6;;2508:55;-1:-1:-1;;;;;;2583:12:6::1;:33;::::0;::::1;::::0;:65:::1;::::0;2617:16;;2508:55;;2583:65:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;2654:36:6;::::1;;::::0;;;:23:::1;:36;::::0;;;;;;:55;;;2720:50;2569:79;;-1:-1:-1;2720:50:6::1;::::0;::::1;::::0;2569:79;;2741:10:::1;::::0;2693:16;;2720:50:::1;:::i;:::-;;;;;;;;1256:1;2330:445:::0;;;;:::o;2905:139::-;-1:-1:-1;;;;;2996:29:6;2977:4;2996:29;;;:23;:29;;;;;;:43;;;2905:139::o;1526:129::-;1280:12:4;:10;:12::i;:::-;1270:6;;-1:-1:-1;;;;;1270:6:4;;;:22;;;1262:67;;;;-1:-1:-1;;;1262:67:4;;;;;;;:::i;:::-;-1:-1:-1;;;;;1611:32:6::1;;::::0;;;1646:4:::1;1611:32;::::0;;;;;;;:39;;-1:-1:-1;;1611:39:6::1;::::0;;::::1;::::0;;1526:129::o;1689:145:4:-;1280:12;:10;:12::i;:::-;1270:6;;-1:-1:-1;;;;;1270:6:4;;;:22;;;1262:67;;;;-1:-1:-1;;;1262:67:4;;;;;;;:::i;:::-;1795:1:::1;1779:6:::0;;1758:40:::1;::::0;-1:-1:-1;;;;;1779:6:4;;::::1;::::0;1758:40:::1;::::0;1795:1;;1758:40:::1;1825:1;1808:19:::0;;-1:-1:-1;;;;;;1808:19:4::1;::::0;;1689:145::o;983:61:6:-;;;;;;;;;;;;;;;:::o;1066:77:4:-;1104:7;1130:6;-1:-1:-1;;;;;1130:6:4;1066:77;:::o;712:64:6:-;;;:::o;3145:394::-;3289:7;3306:20;3356:10;3368:14;3339:44;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3329:55;;;;;;3306:78;;3397:137;3450:12;3479:4;3492:16;3516:12;3397:37;:137::i;:::-;3390:144;3145:394;-1:-1:-1;;;;;3145:394:6:o;1726:133::-;1280:12:4;:10;:12::i;:::-;1270:6;;-1:-1:-1;;;;;1270:6:4;;;:22;;;1262:67;;;;-1:-1:-1;;;1262:67:4;;;;;;;:::i;:::-;-1:-1:-1;;;;;1814:32:6::1;1849:5;1814:32:::0;;;:20:::1;:32;::::0;;;;:40;;-1:-1:-1;;1814:40:6::1;::::0;;1726:133::o;1983:240:4:-;1280:12;:10;:12::i;:::-;1270:6;;-1:-1:-1;;;;;1270:6:4;;;:22;;;1262:67;;;;-1:-1:-1;;;1262:67:4;;;;;;;:::i;:::-;-1:-1:-1;;;;;2071:22:4;::::1;2063:73;;;;-1:-1:-1::0;;;2063:73:4::1;;;;;;;:::i;:::-;2172:6;::::0;;2151:38:::1;::::0;-1:-1:-1;;;;;2151:38:4;;::::1;::::0;2172:6;::::1;::::0;2151:38:::1;::::0;::::1;2199:6;:17:::0;;-1:-1:-1;;;;;;2199:17:4::1;-1:-1:-1::0;;;;;2199:17:4;;;::::1;::::0;;;::::1;::::0;;1983:240::o;1048:67:6:-;;;;;;;;;;;;;:::o;590:104:3:-;677:10;590:104;:::o;3276:387:1:-;3455:7;3472:12;3487:87;3514:10;3532:16;3556:12;3487:19;:87::i;:::-;3472:102;-1:-1:-1;3587:71:1;3472:102;463:66:0;3649:8:1;3587:22;:71::i;:::-;3580:78;3276:387;-1:-1:-1;;;;;;3276:387:1:o;1332:292::-;1480:7;1547:10;1567:16;1593:12;1521:92;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1504:115;;;;;;1497:122;;1332:292;;;;;:::o;2160:276:5:-;2261:7;2280:13;2343:4;2336:12;;2350:8;2360:4;2366:12;2319:60;;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;2319:60:5;;;;;;2296:93;;2319:60;2296:93;;;;;2160:276;-1:-1:-1;;;;;2160:276:5:o;420:241:-1:-;;524:2;512:9;503:7;499:23;495:32;492:2;;;-1:-1;;530:12;492:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;582:63;486:175;-1:-1;;;486:175::o;668:263::-;;783:2;771:9;762:7;758:23;754:32;751:2;;;-1:-1;;789:12;751:2;226:6;220:13;238:33;265:5;238:33;:::i;938:491::-;;;;1076:2;1064:9;1055:7;1051:23;1047:32;1044:2;;;-1:-1;;1082:12;1044:2;363:6;350:20;1134:63;;1234:2;1277:9;1273:22;72:20;97:33;124:5;97:33;:::i;:::-;1038:391;;1242:63;;-1:-1;;;1342:2;1381:22;;;;350:20;;1038:391::o;1436:366::-;;;1557:2;1545:9;1536:7;1532:23;1528:32;1525:2;;;-1:-1;;1563:12;1525:2;-1:-1;;350:20;;;1715:2;1754:22;;;350:20;;-1:-1;1519:283::o;4222:424::-;11398:2;11394:14;;;;-1:-1;;;;;;11394:14;2063:74;;4507:2;4498:12;;2765:37;4609:12;;;4382:264::o;5052:531::-;11398:2;11394:14;;;;-1:-1;;;;;;11394:14;2063:74;;5333:2;5324:12;;2765:37;;;;5435:12;;;2765:37;5546:12;;;5224:359::o;5590:665::-;-1:-1;;;;;;9837:78;;;;2626:56;;11398:2;11394:14;;;;-1:-1;;;;;;11394:14;5895:1;5886:11;;2063:74;5996:12;;;2765:37;6107:12;;;2765:37;6218:12;;;5788:467::o;6262:222::-;-1:-1;;;;;10068:54;;;;2220:37;;6389:2;6374:18;;6360:124::o;6491:460::-;-1:-1;;;;;10068:54;;;2220:37;;10068:54;;;;6854:2;6839:18;;1888:58;6937:2;6922:18;;2765:37;;;;6682:2;6667:18;;6653:298::o;6958:210::-;9750:13;;9743:21;2493:34;;7079:2;7064:18;;7050:118::o;7175:222::-;2765:37;;;7302:2;7287:18;;7273:124::o;7404:333::-;2765:37;;;7723:2;7708:18;;2765:37;7559:2;7544:18;;7530:207::o;8039:416::-;8239:2;8253:47;;;3397:2;8224:18;;;9412:19;-1:-1;;;9452:14;;;3413:39;3471:12;;;8210:245::o;8462:416::-;8662:2;8676:47;;;3722:2;8647:18;;;9412:19;3758:34;9452:14;;;3738:55;-1:-1;;;3813:12;;;3806:30;3855:12;;;8633:245::o;8885:416::-;9085:2;9099:47;;;9070:18;;;9412:19;4142:34;9452:14;;;4122:55;4196:12;;;9056:245::o;11426:117::-;-1:-1;;;;;10068:54;;11485:35;;11475:2;;11534:1;;11524:12;11475:2;11469:74;:::o

ipfs://44deb1f1409c84e4905c6aa60e1ae98941eb488643c4fdd97f25d07ca7cfb420