Token

ERC-20: Shells (SHL)

ERC-20

Overview

Max Total Supply

106,281.510987975672464302 SHL

Holders

2,065

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x8f26d7bab7a73309141a291525c965ecdea7bf42

Filtered by Token Holder

0x8656BCc56955d561BF6c3eEF400137172ff2D958

Balance

2.75327142375090902 SHL

Value

$0.00

0x8656bcc56955d561bf6c3eef400137172ff2d958

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

This contract contains unverified libraries: Shells

Contract Source Code Verified (Exact Match)

Contract Name:

Shell

Compiler Version

v0.5.15+commit.6a57276f

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, GNU AGPLv3 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2020-12-27
*/

// hevm: flattened sources of src/Shell.sol
pragma solidity >0.4.13 >=0.4.23 >=0.5.0 <0.6.0 >=0.5.7 <0.6.0;

////// lib/abdk-libraries-solidity/src/ABDKMath64x64.sol
/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <[email protected]>
 */
/* pragma solidity ^0.5.7; */

/**
 * Smart contract library of mathematical functions operating with signed
 * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
 * basically a simple fraction whose numerator is signed 128-bit integer and
 * denominator is 2^64.  As long as denominator is always the same, there is no
 * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
 * represented by int128 type holding only the numerator.
 */
library ABDKMath64x64 {
  /**
   * Minimum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;

  /**
   * Maximum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

  /**
   * Convert signed 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromInt (int256 x) internal pure returns (int128) {
    require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
    return int128 (x << 64);
  }

  /**
   * Convert signed 64.64 fixed point number into signed 64-bit integer number
   * rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64-bit integer number
   */
  function toInt (int128 x) internal pure returns (int64) {
    return int64 (x >> 64);
  }

  /**
   * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromUInt (uint256 x) internal pure returns (int128) {
    require (x <= 0x7FFFFFFFFFFFFFFF);
    return int128 (x << 64);
  }

  /**
   * Convert signed 64.64 fixed point number into unsigned 64-bit integer
   * number rounding down.  Revert on underflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return unsigned 64-bit integer number
   */
  function toUInt (int128 x) internal pure returns (uint64) {
    require (x >= 0);
    return uint64 (x >> 64);
  }

  /**
   * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
   * number rounding down.  Revert on overflow.
   *
   * @param x signed 128.128-bin fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function from128x128 (int256 x) internal pure returns (int128) {
    int256 result = x >> 64;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Convert signed 64.64 fixed point number into signed 128.128 fixed point
   * number.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 128.128 fixed point number
   */
  function to128x128 (int128 x) internal pure returns (int256) {
    return int256 (x) << 64;
  }

  /**
   * Calculate x + y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function add (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) + y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x - y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sub (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) - y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x * y rounding down.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function mul (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) * y >> 64;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
   * number and y is signed 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y signed 256-bit integer number
   * @return signed 256-bit integer number
   */
  function muli (int128 x, int256 y) internal pure returns (int256) {
    if (x == MIN_64x64) {
      require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
        y <= 0x1000000000000000000000000000000000000000000000000);
      return -y << 63;
    } else {
      bool negativeResult = false;
      if (x < 0) {
        x = -x;
        negativeResult = true;
      }
      if (y < 0) {
        y = -y; // We rely on overflow behavior here
        negativeResult = !negativeResult;
      }
      uint256 absoluteResult = mulu (x, uint256 (y));
      if (negativeResult) {
        require (absoluteResult <=
          0x8000000000000000000000000000000000000000000000000000000000000000);
        return -int256 (absoluteResult); // We rely on overflow behavior here
      } else {
        require (absoluteResult <=
          0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
        return int256 (absoluteResult);
      }
    }
  }

  /**
   * Calculate x * y rounding down, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y unsigned 256-bit integer number
   * @return unsigned 256-bit integer number
   */
  function mulu (int128 x, uint256 y) internal pure returns (uint256) {
    if (y == 0) return 0;

    require (x >= 0);

    uint256 lo = (uint256 (x) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
    uint256 hi = uint256 (x) * (y >> 128);

    require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    hi <<= 64;

    require (hi <=
      0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
    return hi + lo;
  }

  /**
   * Calculate x / y rounding towards zero.  Revert on overflow or when y is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function div (int128 x, int128 y) internal pure returns (int128) {
    require (y != 0);
    int256 result = (int256 (x) << 64) / y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are signed 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x signed 256-bit integer number
   * @param y signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divi (int256 x, int256 y) internal pure returns (int128) {
    require (y != 0);

    bool negativeResult = false;
    if (x < 0) {
      x = -x; // We rely on overflow behavior here
      negativeResult = true;
    }
    if (y < 0) {
      y = -y; // We rely on overflow behavior here
      negativeResult = !negativeResult;
    }
    uint128 absoluteResult = divuu (uint256 (x), uint256 (y));
    if (negativeResult) {
      require (absoluteResult <= 0x80000000000000000000000000000000);
      return -int128 (absoluteResult); // We rely on overflow behavior here
    } else {
      require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return int128 (absoluteResult); // We rely on overflow behavior here
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divu (uint256 x, uint256 y) internal pure returns (int128) {
    require (y != 0);
    uint128 result = divuu (x, y);
    require (result <= uint128 (MAX_64x64));
    return int128 (result);
  }

  /**
   * Calculate -x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function neg (int128 x) internal pure returns (int128) {
    require (x != MIN_64x64);
    return -x;
  }

  /**
   * Calculate |x|.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function abs (int128 x) internal pure returns (int128) {
    require (x != MIN_64x64);
    return x < 0 ? -x : x;
  }

  /**
   * Calculate 1 / x rounding towards zero.  Revert on overflow or when x is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function inv (int128 x) internal pure returns (int128) {
    require (x != 0);
    int256 result = int256 (0x100000000000000000000000000000000) / x;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function avg (int128 x, int128 y) internal pure returns (int128) {
    return int128 ((int256 (x) + int256 (y)) >> 1);
  }

  /**
   * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
   * Revert on overflow or in case x * y is negative.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function gavg (int128 x, int128 y) internal pure returns (int128) {
    int256 m = int256 (x) * int256 (y);
    require (m >= 0);
    require (m <
        0x4000000000000000000000000000000000000000000000000000000000000000);
    return int128 (sqrtu (uint256 (m), uint256 (x) + uint256 (y) >> 1));
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y uint256 value
   * @return signed 64.64-bit fixed point number
   */
  function pow (int128 x, uint256 y) internal pure returns (int128) {
    uint256 absoluteResult;
    bool negativeResult = false;
    if (x >= 0) {
      absoluteResult = powu (uint256 (x) << 63, y);
    } else {
      // We rely on overflow behavior here
      absoluteResult = powu (uint256 (uint128 (-x)) << 63, y);
      negativeResult = y & 1 > 0;
    }

    absoluteResult >>= 63;

    if (negativeResult) {
      require (absoluteResult <= 0x80000000000000000000000000000000);
      return -int128 (absoluteResult); // We rely on overflow behavior here
    } else {
      require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return int128 (absoluteResult); // We rely on overflow behavior here
    }
  }

  /**
   * Calculate sqrt (x) rounding down.  Revert if x < 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sqrt (int128 x) internal pure returns (int128) {
    require (x >= 0);
    return int128 (sqrtu (uint256 (x) << 64, 0x10000000000000000));
  }

  /**
   * Calculate binary logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function log_2 (int128 x) internal pure returns (int128) {
    require (x > 0);

    int256 msb = 0;
    int256 xc = x;
    if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
    if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
    if (xc >= 0x10000) { xc >>= 16; msb += 16; }
    if (xc >= 0x100) { xc >>= 8; msb += 8; }
    if (xc >= 0x10) { xc >>= 4; msb += 4; }
    if (xc >= 0x4) { xc >>= 2; msb += 2; }
    if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

    int256 result = msb - 64 << 64;
    uint256 ux = uint256 (x) << 127 - msb;
    for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
      ux *= ux;
      uint256 b = ux >> 255;
      ux >>= 127 + b;
      result += bit * int256 (b);
    }

    return int128 (result);
  }

  /**
   * Calculate natural logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function ln (int128 x) internal pure returns (int128) {
    require (x > 0);

    return int128 (
        uint256 (log_2 (x)) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128);
  }

  /**
   * Calculate binary exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp_2 (int128 x) internal pure returns (int128) {
    require (x < 0x400000000000000000); // Overflow

    if (x < -0x400000000000000000) return 0; // Underflow

    uint256 result = 0x80000000000000000000000000000000;

    if (x & 0x8000000000000000 > 0)
      result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
    if (x & 0x4000000000000000 > 0)
      result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
    if (x & 0x2000000000000000 > 0)
      result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
    if (x & 0x1000000000000000 > 0)
      result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
    if (x & 0x800000000000000 > 0)
      result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
    if (x & 0x400000000000000 > 0)
      result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
    if (x & 0x200000000000000 > 0)
      result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
    if (x & 0x100000000000000 > 0)
      result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
    if (x & 0x80000000000000 > 0)
      result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
    if (x & 0x40000000000000 > 0)
      result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
    if (x & 0x20000000000000 > 0)
      result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
    if (x & 0x10000000000000 > 0)
      result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
    if (x & 0x8000000000000 > 0)
      result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
    if (x & 0x4000000000000 > 0)
      result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
    if (x & 0x2000000000000 > 0)
      result = result * 0x1000162E525EE054754457D5995292026 >> 128;
    if (x & 0x1000000000000 > 0)
      result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
    if (x & 0x800000000000 > 0)
      result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
    if (x & 0x400000000000 > 0)
      result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
    if (x & 0x200000000000 > 0)
      result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
    if (x & 0x100000000000 > 0)
      result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
    if (x & 0x80000000000 > 0)
      result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
    if (x & 0x40000000000 > 0)
      result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
    if (x & 0x20000000000 > 0)
      result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
    if (x & 0x10000000000 > 0)
      result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
    if (x & 0x8000000000 > 0)
      result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
    if (x & 0x4000000000 > 0)
      result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
    if (x & 0x2000000000 > 0)
      result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
    if (x & 0x1000000000 > 0)
      result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
    if (x & 0x800000000 > 0)
      result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
    if (x & 0x400000000 > 0)
      result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
    if (x & 0x200000000 > 0)
      result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
    if (x & 0x100000000 > 0)
      result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
    if (x & 0x80000000 > 0)
      result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
    if (x & 0x40000000 > 0)
      result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
    if (x & 0x20000000 > 0)
      result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
    if (x & 0x10000000 > 0)
      result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
    if (x & 0x8000000 > 0)
      result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
    if (x & 0x4000000 > 0)
      result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
    if (x & 0x2000000 > 0)
      result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
    if (x & 0x1000000 > 0)
      result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
    if (x & 0x800000 > 0)
      result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
    if (x & 0x400000 > 0)
      result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
    if (x & 0x200000 > 0)
      result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
    if (x & 0x100000 > 0)
      result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
    if (x & 0x80000 > 0)
      result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
    if (x & 0x40000 > 0)
      result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
    if (x & 0x20000 > 0)
      result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
    if (x & 0x10000 > 0)
      result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
    if (x & 0x8000 > 0)
      result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
    if (x & 0x4000 > 0)
      result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
    if (x & 0x2000 > 0)
      result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
    if (x & 0x1000 > 0)
      result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
    if (x & 0x800 > 0)
      result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
    if (x & 0x400 > 0)
      result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
    if (x & 0x200 > 0)
      result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
    if (x & 0x100 > 0)
      result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
    if (x & 0x80 > 0)
      result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
    if (x & 0x40 > 0)
      result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
    if (x & 0x20 > 0)
      result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
    if (x & 0x10 > 0)
      result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
    if (x & 0x8 > 0)
      result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
    if (x & 0x4 > 0)
      result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
    if (x & 0x2 > 0)
      result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
    if (x & 0x1 > 0)
      result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;

    result >>= 63 - (x >> 64);
    require (result <= uint256 (MAX_64x64));

    return int128 (result);
  }

  /**
   * Calculate natural exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp (int128 x) internal pure returns (int128) {
    require (x < 0x400000000000000000); // Overflow

    if (x < -0x400000000000000000) return 0; // Underflow

    return exp_2 (
        int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return unsigned 64.64-bit fixed point number
   */
  function divuu (uint256 x, uint256 y) private pure returns (uint128) {
    require (y != 0);

    uint256 result;

    if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
      result = (x << 64) / y;
    else {
      uint256 msb = 192;
      uint256 xc = x >> 192;
      if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
      if (xc >= 0x10000) { xc >>= 16; msb += 16; }
      if (xc >= 0x100) { xc >>= 8; msb += 8; }
      if (xc >= 0x10) { xc >>= 4; msb += 4; }
      if (xc >= 0x4) { xc >>= 2; msb += 2; }
      if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

      result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1);
      require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

      uint256 hi = result * (y >> 128);
      uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

      uint256 xh = x >> 192;
      uint256 xl = x << 64;

      if (xl < lo) xh -= 1;
      xl -= lo; // We rely on overflow behavior here
      lo = hi << 128;
      if (xl < lo) xh -= 1;
      xl -= lo; // We rely on overflow behavior here

      assert (xh == hi >> 128);

      result += xl / y;
    }

    require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    return uint128 (result);
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point
   * number and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x unsigned 129.127-bit fixed point number
   * @param y uint256 value
   * @return unsigned 129.127-bit fixed point number
   */
  function powu (uint256 x, uint256 y) private pure returns (uint256) {
    if (y == 0) return 0x80000000000000000000000000000000;
    else if (x == 0) return 0;
    else {
      int256 msb = 0;
      uint256 xc = x;
      if (xc >= 0x100000000000000000000000000000000) { xc >>= 128; msb += 128; }
      if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
      if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
      if (xc >= 0x10000) { xc >>= 16; msb += 16; }
      if (xc >= 0x100) { xc >>= 8; msb += 8; }
      if (xc >= 0x10) { xc >>= 4; msb += 4; }
      if (xc >= 0x4) { xc >>= 2; msb += 2; }
      if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

      int256 xe = msb - 127;
      if (xe > 0) x >>= xe;
      else x <<= -xe;

      uint256 result = 0x80000000000000000000000000000000;
      int256 re = 0;

      while (y > 0) {
        if (y & 1 > 0) {
          result = result * x;
          y -= 1;
          re += xe;
          if (result >=
            0x8000000000000000000000000000000000000000000000000000000000000000) {
            result >>= 128;
            re += 1;
          } else result >>= 127;
          if (re < -127) return 0; // Underflow
          require (re < 128); // Overflow
        } else {
          x = x * x;
          y >>= 1;
          xe <<= 1;
          if (x >=
            0x8000000000000000000000000000000000000000000000000000000000000000) {
            x >>= 128;
            xe += 1;
          } else x >>= 127;
          if (xe < -127) return 0; // Underflow
          require (xe < 128); // Overflow
        }
      }

      if (re > 0) result <<= re;
      else if (re < 0) result >>= -re;

      return result;
    }
  }

  /**
   * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
   * number.
   *
   * @param x unsigned 256-bit integer number
   * @return unsigned 128-bit integer number
   */
  function sqrtu (uint256 x, uint256 r) private pure returns (uint128) {
    if (x == 0) return 0;
    else {
      require (r > 0);
      while (true) {
        uint256 rr = x / r;
        if (r == rr || r + 1 == rr) return uint128 (r);
        else if (r == rr + 1) return uint128 (rr);
        r = r + rr + 1 >> 1;
      }
    }
  }
}

////// src/interfaces/IAssimilator.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/* pragma solidity ^0.5.0; */

interface IAssimilator {
    function intakeRaw (uint256 amount) external returns (int128);
    function intakeRawAndGetBalance (uint256 amount) external returns (int128, int128);
    function intakeNumeraire (int128 amount) external returns (uint256);
    function outputRaw (address dst, uint256 amount) external returns (int128);
    function outputRawAndGetBalance (address dst, uint256 amount) external returns (int128, int128);
    function outputNumeraire (address dst, int128 amount) external returns (uint256);
    function viewRawAmount (int128) external view returns (uint256);
    function viewNumeraireAmount (uint256) external view returns (int128);
    function viewNumeraireBalance (address) external view returns (int128);
    function viewNumeraireAmountAndBalance (address, uint256) external view returns (int128, int128);
}
////// src/Assimilators.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/* pragma solidity ^0.5.0; */

/* import "./interfaces/IAssimilator.sol"; */
/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */

library Assimilators {

    using ABDKMath64x64 for int128;
    IAssimilator constant iAsmltr = IAssimilator(address(0));

    function delegate(address _callee, bytes memory _data) internal returns (bytes memory) {

        (bool _success, bytes memory returnData_) = _callee.delegatecall(_data);

        assembly { if eq(_success, 0) { revert(add(returnData_, 0x20), returndatasize()) } }

        return returnData_;

    }

    function viewRawAmount (address _assim, int128 _amt) internal view returns (uint256 amount_) {

        amount_ = IAssimilator(_assim).viewRawAmount(_amt);

    }

    function viewNumeraireAmount (address _assim, uint256 _amt) internal view returns (int128 amt_) {

        amt_ = IAssimilator(_assim).viewNumeraireAmount(_amt);

    }

    function viewNumeraireAmountAndBalance (address _assim, uint256 _amt) internal view returns (int128 amt_, int128 bal_) {

        ( amt_, bal_ ) = IAssimilator(_assim).viewNumeraireAmountAndBalance(address(this), _amt);

    }

    function viewNumeraireBalance (address _assim) internal view returns (int128 bal_) {

        bal_ = IAssimilator(_assim).viewNumeraireBalance(address(this));

    }

    function intakeRaw (address _assim, uint256 _amt) internal returns (int128 amt_) {

        bytes memory data = abi.encodeWithSelector(iAsmltr.intakeRaw.selector, _amt);

        amt_ = abi.decode(delegate(_assim, data), (int128));

    }

    function intakeRawAndGetBalance (address _assim, uint256 _amt) internal returns (int128 amt_, int128 bal_) {

        bytes memory data = abi.encodeWithSelector(iAsmltr.intakeRawAndGetBalance.selector, _amt);

        ( amt_, bal_ ) = abi.decode(delegate(_assim, data), (int128,int128));

    }

    function intakeNumeraire (address _assim, int128 _amt) internal returns (uint256 amt_) {

        bytes memory data = abi.encodeWithSelector(iAsmltr.intakeNumeraire.selector, _amt);

        amt_ = abi.decode(delegate(_assim, data), (uint256));

    }

    function outputRaw (address _assim, address _dst, uint256 _amt) internal returns (int128 amt_ ) {

        bytes memory data = abi.encodeWithSelector(iAsmltr.outputRaw.selector, _dst, _amt);

        amt_ = abi.decode(delegate(_assim, data), (int128));

        amt_ = amt_.neg();

    }

    function outputRawAndGetBalance (address _assim, address _dst, uint256 _amt) internal returns (int128 amt_, int128 bal_) {

        bytes memory data = abi.encodeWithSelector(iAsmltr.outputRawAndGetBalance.selector, _dst, _amt);

        ( amt_, bal_ ) = abi.decode(delegate(_assim, data), (int128,int128));

        amt_ = amt_.neg();

    }

    function outputNumeraire (address _assim, address _dst, int128 _amt) internal returns (uint256 amt_) {

        bytes memory data = abi.encodeWithSelector(iAsmltr.outputNumeraire.selector, _dst, _amt.abs());

        amt_ = abi.decode(delegate(_assim, data), (uint256));

    }

}
////// src/UnsafeMath64x64.sol
/* pragma solidity ^0.5.0; */

library UnsafeMath64x64 {

  /**
   * Calculate x * y rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */

  function us_mul (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) * y >> 64;
    return int128 (result);
  }

  /**
   * Calculate x / y rounding towards zero.  Revert on overflow or when y is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */

  function us_div (int128 x, int128 y) internal pure returns (int128) {
    int256 result = (int256 (x) << 64) / y;
    return int128 (result);
  }

}

////// src/PartitionedLiquidity.sol
/* pragma solidity ^0.5.0; */

/* import "./Assimilators.sol"; */

/* import "./ShellStorage.sol"; */

/* import "./UnsafeMath64x64.sol"; */

library PartitionedLiquidity {

    using ABDKMath64x64 for uint;
    using ABDKMath64x64 for int128;
    using UnsafeMath64x64 for int128;

    event PoolPartitioned(bool);

    event PartitionRedeemed(address indexed token, address indexed redeemer, uint value);

    int128 constant ONE = 0x10000000000000000;

    function partition (
        ShellStorage.Shell storage shell,
        mapping (address => ShellStorage.PartitionTicket) storage partitionTickets
    ) external {

        uint _length = shell.assets.length;

        ShellStorage.PartitionTicket storage totalSupplyTicket = partitionTickets[address(this)];

        totalSupplyTicket.initialized = true;

        for (uint i = 0; i < _length; i++) totalSupplyTicket.claims.push(shell.totalSupply);

        emit PoolPartitioned(true);

    }

    function viewPartitionClaims (
        ShellStorage.Shell storage shell,
        mapping (address => ShellStorage.PartitionTicket) storage partitionTickets,
        address _addr
    ) external view returns (
        uint[] memory claims_
    ) {

        ShellStorage.PartitionTicket storage ticket = partitionTickets[_addr];

        if (ticket.initialized) return ticket.claims;

        uint _length = shell.assets.length;
        uint[] memory claims_ = new uint[](_length);
        uint _balance = shell.balances[msg.sender];

        for (uint i = 0; i < _length; i++) claims_[i] = _balance;

        return claims_;

    }

    function partitionedWithdraw (
        ShellStorage.Shell storage shell,
        mapping (address => ShellStorage.PartitionTicket) storage partitionTickets,
        address[] calldata _derivatives,
        uint[] calldata _withdrawals
    ) external returns (
        uint[] memory
    ) {

        uint _length = shell.assets.length;
        uint _balance = shell.balances[msg.sender];

        ShellStorage.PartitionTicket storage totalSuppliesTicket = partitionTickets[address(this)];
        ShellStorage.PartitionTicket storage ticket = partitionTickets[msg.sender];

        if (!ticket.initialized) {

            for (uint i = 0; i < _length; i++) ticket.claims.push(_balance);
            ticket.initialized = true;

        }

        _length = _derivatives.length;

        uint[] memory withdrawals_ = new uint[](_length);

        for (uint i = 0; i < _length; i++) {

            ShellStorage.Assimilator memory _assim = shell.assimilators[_derivatives[i]];

            require(totalSuppliesTicket.claims[_assim.ix] >= _withdrawals[i], "Shell/burn-exceeds-total-supply");
            
            require(ticket.claims[_assim.ix] >= _withdrawals[i], "Shell/insufficient-balance");

            require(_assim.addr != address(0), "Shell/unsupported-asset");

            int128 _reserveBalance = Assimilators.viewNumeraireBalance(_assim.addr);

            int128 _multiplier = _withdrawals[i].divu(1e18)
                .div(totalSuppliesTicket.claims[_assim.ix].divu(1e18));

            totalSuppliesTicket.claims[_assim.ix] = totalSuppliesTicket.claims[_assim.ix] - _withdrawals[i];

            ticket.claims[_assim.ix] = ticket.claims[_assim.ix] - _withdrawals[i];

            uint _withdrawal = Assimilators.outputNumeraire(
                _assim.addr,
                msg.sender,
                _reserveBalance.mul(_multiplier)
            );

            withdrawals_[i] = _withdrawal;

            emit PartitionRedeemed(_derivatives[i], msg.sender, withdrawals_[i]);

        }

        return withdrawals_;

    }

}
////// src/ProportionalLiquidity.sol
/* pragma solidity ^0.5.0; */

/* import "./Assimilators.sol"; */

/* import "./ShellStorage.sol"; */

/* import "./UnsafeMath64x64.sol"; */

/* import "./ShellMath.sol"; */


library ProportionalLiquidity {

    using ABDKMath64x64 for uint;
    using ABDKMath64x64 for int128;
    using UnsafeMath64x64 for int128;

    event Transfer(address indexed from, address indexed to, uint256 value);

    int128 constant ONE = 0x10000000000000000;
    int128 constant ONE_WEI = 0x12;

    function proportionalDeposit (
        ShellStorage.Shell storage shell,
        uint256 _deposit
    ) external returns (
        uint256 shells_,
        uint[] memory
    ) {

        int128 __deposit = _deposit.divu(1e18);

        uint _length = shell.assets.length;

        uint[] memory deposits_ = new uint[](_length);
        
        ( int128 _oGLiq, int128[] memory _oBals ) = getGrossLiquidityAndBalances(shell);

        if (_oGLiq == 0) {

            for (uint i = 0; i < _length; i++) {

                deposits_[i] = Assimilators.intakeNumeraire(shell.assets[i].addr, __deposit.mul(shell.weights[i]));

            }

        } else {

            int128 _multiplier = __deposit.div(_oGLiq);

            for (uint i = 0; i < _length; i++) {

                deposits_[i] = Assimilators.intakeNumeraire(shell.assets[i].addr, _oBals[i].mul(_multiplier));

            }

        }
        
        int128 _totalShells = shell.totalSupply.divu(1e18);
        
        int128 _newShells = _totalShells > 0
            ? __deposit.div(_oGLiq).mul(_totalShells)
            : __deposit;

        requireLiquidityInvariant(
            shell, 
            _totalShells,
            _newShells, 
            _oGLiq, 
            _oBals
        );        

        mint(shell, msg.sender, shells_ = _newShells.mulu(1e18));

        return (shells_, deposits_);

    }
    
    
    function viewProportionalDeposit (
        ShellStorage.Shell storage shell,
        uint256 _deposit
    ) external view returns (
        uint shells_,
        uint[] memory
    ) {

        int128 __deposit = _deposit.divu(1e18);

        uint _length = shell.assets.length;

        ( int128 _oGLiq, int128[] memory _oBals ) = getGrossLiquidityAndBalances(shell);

        uint[] memory deposits_ = new uint[](_length);

        if (_oGLiq == 0) {

            for (uint i = 0; i < _length; i++) {

                deposits_[i] = Assimilators.viewRawAmount(
                    shell.assets[i].addr,
                    __deposit.mul(shell.weights[i])
                );

            }

        } else {

            int128 _multiplier = __deposit.div(_oGLiq);

            for (uint i = 0; i < _length; i++) {

                deposits_[i] = Assimilators.viewRawAmount(
                    shell.assets[i].addr,
                    _oBals[i].mul(_multiplier)
                );

            }

        }
        
        int128 _totalShells = shell.totalSupply.divu(1e18);
        
        int128 _newShells = _totalShells > 0
            ? __deposit.div(_oGLiq).mul(_totalShells)
            : __deposit;
        
        shells_ = _newShells.mulu(1e18);

        return ( shells_, deposits_ );

    }

    function proportionalWithdraw (
        ShellStorage.Shell storage shell,
        uint256 _withdrawal
    ) external returns (
        uint[] memory
    ) {

        uint _length = shell.assets.length;

        ( int128 _oGLiq, int128[] memory _oBals ) = getGrossLiquidityAndBalances(shell);

        uint[] memory withdrawals_ = new uint[](_length);
        
        int128 _totalShells = shell.totalSupply.divu(1e18);
        int128 __withdrawal = _withdrawal.divu(1e18);

        int128 _multiplier = __withdrawal
            .mul(ONE - shell.epsilon)
            .div(_totalShells);

        for (uint i = 0; i < _length; i++) {

            withdrawals_[i] = Assimilators.outputNumeraire(
                shell.assets[i].addr,
                msg.sender,
                _oBals[i].mul(_multiplier)
            );

        }

        requireLiquidityInvariant(
            shell, 
            _totalShells, 
            __withdrawal.neg(), 
            _oGLiq, 
            _oBals
        );
        
        burn(shell, msg.sender, _withdrawal);

        return withdrawals_;

    }
    
    function viewProportionalWithdraw (
        ShellStorage.Shell storage shell,
        uint256 _withdrawal
    ) external view returns (
        uint[] memory
    ) {

        uint _length = shell.assets.length;

        ( int128 _oGLiq, int128[] memory _oBals ) = getGrossLiquidityAndBalances(shell);

        uint[] memory withdrawals_ = new uint[](_length);

        int128 _multiplier = _withdrawal.divu(1e18)
            .mul(ONE - shell.epsilon)
            .div(shell.totalSupply.divu(1e18));

        for (uint i = 0; i < _length; i++) {

            withdrawals_[i] = Assimilators.viewRawAmount(shell.assets[i].addr, _oBals[i].mul(_multiplier));

        }

        return withdrawals_;

    }

    function getGrossLiquidityAndBalances (
        ShellStorage.Shell storage shell
    ) internal view returns (
        int128 grossLiquidity_,
        int128[] memory
    ) {
        
        uint _length = shell.assets.length;

        int128[] memory balances_ = new int128[](_length);
        
        for (uint i = 0; i < _length; i++) {

            int128 _bal = Assimilators.viewNumeraireBalance(shell.assets[i].addr);
            
            balances_[i] = _bal;
            grossLiquidity_ += _bal;
            
        }
        
        return (grossLiquidity_, balances_);

    }
    
    function requireLiquidityInvariant (
        ShellStorage.Shell storage shell,
        int128 _shells,
        int128 _newShells,
        int128 _oGLiq,
        int128[] memory _oBals
    ) private {
    
        ( int128 _nGLiq, int128[] memory _nBals ) = getGrossLiquidityAndBalances(shell);
        
        int128 _beta = shell.beta;
        int128 _delta = shell.delta;
        int128[] memory _weights = shell.weights;
        
        int128 _omega = ShellMath.calculateFee(_oGLiq, _oBals, _beta, _delta, _weights);

        int128 _psi = ShellMath.calculateFee(_nGLiq, _nBals, _beta, _delta, _weights);

        ShellMath.enforceLiquidityInvariant(_shells, _newShells, _oGLiq, _nGLiq, _omega, _psi);
        
    }

    function burn (ShellStorage.Shell storage shell, address account, uint256 amount) private {

        shell.balances[account] = burn_sub(shell.balances[account], amount);

        shell.totalSupply = burn_sub(shell.totalSupply, amount);

        emit Transfer(msg.sender, address(0), amount);

    }

    function mint (ShellStorage.Shell storage shell, address account, uint256 amount) private {

        shell.totalSupply = mint_add(shell.totalSupply, amount);

        shell.balances[account] = mint_add(shell.balances[account], amount);

        emit Transfer(address(0), msg.sender, amount);

    }

    function mint_add(uint x, uint y) private pure returns (uint z) {

        require((z = x + y) >= x, "Shell/mint-overflow");

    }

    function burn_sub(uint x, uint y) private pure returns (uint z) {

        require((z = x - y) <= x, "Shell/burn-underflow");

    }


}
////// src/SelectiveLiquidity.sol
/* pragma solidity ^0.5.0; */

/* import "./Assimilators.sol"; */

/* import "./ShellStorage.sol"; */

/* import "./ShellMath.sol"; */

/* import "./UnsafeMath64x64.sol"; */

/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */


library SelectiveLiquidity {

    using ABDKMath64x64 for int128;
    using UnsafeMath64x64 for int128;

    event Transfer(address indexed from, address indexed to, uint256 value);

    int128 constant ONE = 0x10000000000000000;

    function selectiveDeposit (
        ShellStorage.Shell storage shell,
        address[] calldata _derivatives,
        uint[] calldata _amounts,
        uint _minShells
    ) external returns (
        uint shells_
    ) {

        (   int128 _oGLiq,
            int128 _nGLiq,
            int128[] memory _oBals,
            int128[] memory _nBals ) = getLiquidityDepositData(shell, _derivatives, _amounts);

        int128 _shells = ShellMath.calculateLiquidityMembrane(shell, _oGLiq, _nGLiq, _oBals, _nBals);

        shells_ = _shells.mulu(1e18);

        require(_minShells < shells_, "Shell/under-minimum-shells");

        mint(shell, msg.sender, shells_);

    }

    function viewSelectiveDeposit (
        ShellStorage.Shell storage shell,
        address[] calldata _derivatives,
        uint[] calldata _amounts
    ) external view returns (
        uint shells_
    ) {

        (   int128 _oGLiq,
            int128 _nGLiq,
            int128[] memory _oBals,
            int128[] memory _nBals ) = viewLiquidityDepositData(shell, _derivatives, _amounts);

        int128 _shells = ShellMath.calculateLiquidityMembrane(shell, _oGLiq, _nGLiq, _oBals, _nBals);

        shells_ = _shells.mulu(1e18);

    }

    function selectiveWithdraw (
        ShellStorage.Shell storage shell,
        address[] calldata _derivatives,
        uint[] calldata _amounts,
        uint _maxShells
    ) external returns (
        uint256 shells_
    ) {

        (   int128 _oGLiq,
            int128 _nGLiq,
            int128[] memory _oBals,
            int128[] memory _nBals ) = getLiquidityWithdrawData(shell, _derivatives, msg.sender, _amounts);

        int128 _shells = ShellMath.calculateLiquidityMembrane(shell, _oGLiq, _nGLiq, _oBals, _nBals);

        _shells = _shells.neg().us_mul(ONE + shell.epsilon);

        shells_ = _shells.mulu(1e18);

        require(shells_ < _maxShells, "Shell/above-maximum-shells");

        burn(shell, msg.sender, shells_);

    }

    function viewSelectiveWithdraw (
        ShellStorage.Shell storage shell,
        address[] calldata _derivatives,
        uint[] calldata _amounts
    ) external view returns (
        uint shells_
    ) {

        (   int128 _oGLiq,
            int128 _nGLiq,
            int128[] memory _oBals,
            int128[] memory _nBals ) = viewLiquidityWithdrawData(shell, _derivatives, _amounts);

        int128 _shells = ShellMath.calculateLiquidityMembrane(shell, _oGLiq, _nGLiq, _oBals, _nBals);

        _shells = _shells.neg().us_mul(ONE + shell.epsilon);

        shells_ = _shells.mulu(1e18);

    }

    function getLiquidityDepositData (
        ShellStorage.Shell storage shell,
        address[] memory _derivatives,
        uint[] memory _amounts
    ) private returns (
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = shell.weights.length;
        int128[] memory oBals_ = new int128[](_length);
        int128[] memory nBals_ = new int128[](_length);

        for (uint i = 0; i < _derivatives.length; i++) {

            ShellStorage.Assimilator memory _assim = shell.assimilators[_derivatives[i]];

            require(_assim.addr != address(0), "Shell/unsupported-derivative");

            if ( nBals_[_assim.ix] == 0 && 0 == oBals_[_assim.ix]) {

                ( int128 _amount, int128 _balance ) = Assimilators.intakeRawAndGetBalance(_assim.addr, _amounts[i]);

                nBals_[_assim.ix] = _balance;

                oBals_[_assim.ix] = _balance.sub(_amount);

            } else {

                int128 _amount = Assimilators.intakeRaw(_assim.addr, _amounts[i]);

                nBals_[_assim.ix] = nBals_[_assim.ix].add(_amount);

            }

        }

        return completeLiquidityData(shell, oBals_, nBals_);

    }

    function getLiquidityWithdrawData (
        ShellStorage.Shell storage shell,
        address[] memory _derivatives,
        address _rcpnt,
        uint[] memory _amounts
    ) private returns (
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = shell.weights.length;
        int128[] memory oBals_ = new int128[](_length);
        int128[] memory nBals_ = new int128[](_length);

        for (uint i = 0; i < _derivatives.length; i++) {

            ShellStorage.Assimilator memory _assim = shell.assimilators[_derivatives[i]];

            require(_assim.addr != address(0), "Shell/unsupported-derivative");

            if ( nBals_[_assim.ix] == 0 && 0 == oBals_[_assim.ix]) {

                ( int128 _amount, int128 _balance ) = Assimilators.outputRawAndGetBalance(_assim.addr, _rcpnt, _amounts[i]);

                nBals_[_assim.ix] = _balance;
                oBals_[_assim.ix] = _balance.sub(_amount);

            } else {

                int128 _amount = Assimilators.outputRaw(_assim.addr, _rcpnt, _amounts[i]);

                nBals_[_assim.ix] = nBals_[_assim.ix].add(_amount);

            }

        }

        return completeLiquidityData(shell, oBals_, nBals_);

    }

    function viewLiquidityDepositData (
        ShellStorage.Shell storage shell,
        address[] memory _derivatives,
        uint[] memory _amounts
    ) private view returns (
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = shell.assets.length;
        int128[] memory oBals_ = new int128[](_length);
        int128[] memory nBals_ = new int128[](_length);

        for (uint i = 0; i < _derivatives.length; i++) {

            ShellStorage.Assimilator memory _assim = shell.assimilators[_derivatives[i]];

            require(_assim.addr != address(0), "Shell/unsupported-derivative");

            if ( nBals_[_assim.ix] == 0 && 0 == oBals_[_assim.ix]) {

                ( int128 _amount, int128 _balance ) = Assimilators.viewNumeraireAmountAndBalance(_assim.addr, _amounts[i]);

                nBals_[_assim.ix] = _balance.add(_amount);

                oBals_[_assim.ix] = _balance;

            } else {

                int128 _amount = Assimilators.viewNumeraireAmount(_assim.addr, _amounts[i]);

                nBals_[_assim.ix] = nBals_[_assim.ix].add(_amount);

            }

        }

        return completeLiquidityData(shell, oBals_, nBals_);

    }

    function viewLiquidityWithdrawData (
        ShellStorage.Shell storage shell,
        address[] memory _derivatives,
        uint[] memory _amounts
    ) private view returns (
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = shell.assets.length;
        int128[] memory oBals_ = new int128[](_length);
        int128[] memory nBals_ = new int128[](_length);

        for (uint i = 0; i < _derivatives.length; i++) {

            ShellStorage.Assimilator memory _assim = shell.assimilators[_derivatives[i]];

            require(_assim.addr != address(0), "Shell/unsupported-derivative");

            if ( nBals_[_assim.ix] == 0 && 0 == oBals_[_assim.ix]) {

                ( int128 _amount, int128 _balance ) = Assimilators.viewNumeraireAmountAndBalance(_assim.addr, _amounts[i]);

                nBals_[_assim.ix] = _balance.sub(_amount);

                oBals_[_assim.ix] = _balance;

            } else {

                int128 _amount = Assimilators.viewNumeraireAmount(_assim.addr, _amounts[i]);

                nBals_[_assim.ix] = nBals_[_assim.ix].sub(_amount);

            }

        }

        return completeLiquidityData(shell, oBals_, nBals_);

    }

    function completeLiquidityData (
        ShellStorage.Shell storage shell,
        int128[] memory oBals_,
        int128[] memory nBals_
    ) private view returns (
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = oBals_.length;

        for (uint i = 0; i < _length; i++) {

            if (oBals_[i] == 0 && 0 == nBals_[i]) {

                nBals_[i] = oBals_[i] = Assimilators.viewNumeraireBalance(shell.assets[i].addr);
                
            }

            oGLiq_ += oBals_[i];
            nGLiq_ += nBals_[i];

        }

        return ( oGLiq_, nGLiq_, oBals_, nBals_ );

    }

    function burn (ShellStorage.Shell storage shell, address account, uint256 amount) private {

        shell.balances[account] = burn_sub(shell.balances[account], amount);

        shell.totalSupply = burn_sub(shell.totalSupply, amount);

        emit Transfer(msg.sender, address(0), amount);

    }

    function mint (ShellStorage.Shell storage shell, address account, uint256 amount) private {

        shell.totalSupply = mint_add(shell.totalSupply, amount);

        shell.balances[account] = mint_add(shell.balances[account], amount);

        emit Transfer(address(0), msg.sender, amount);

    }

    function mint_add(uint x, uint y) private pure returns (uint z) {
        require((z = x + y) >= x, "Shell/mint-overflow");
    }

    function burn_sub(uint x, uint y) private pure returns (uint z) {
        require((z = x - y) <= x, "Shell/burn-underflow");
    }

}
////// src/Shells.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/* pragma solidity ^0.5.0; */

/* import "./ShellStorage.sol"; */

/* import "./Assimilators.sol"; */

/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */

library Shells {

    using ABDKMath64x64 for int128;

    event Approval(address indexed _owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

    function add(uint x, uint y, string memory errorMessage) private pure returns (uint z) {
        require((z = x + y) >= x, errorMessage);
    }

    function sub(uint x, uint y, string memory errorMessage) private pure returns (uint z) {
        require((z = x - y) <= x, errorMessage);
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(ShellStorage.Shell storage shell, address recipient, uint256 amount) external returns (bool) {
        _transfer(shell, msg.sender, recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(ShellStorage.Shell storage shell, address spender, uint256 amount) external returns (bool) {
        _approve(shell, msg.sender, 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(ShellStorage.Shell storage shell, address sender, address recipient, uint256 amount) external returns (bool) {
        _transfer(shell, sender, recipient, amount);
        _approve(shell, sender, msg.sender, sub(shell.allowances[sender][msg.sender], amount, "Shell/insufficient-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(ShellStorage.Shell storage shell, address spender, uint256 addedValue) external returns (bool) {
        _approve(shell, msg.sender, spender, add(shell.allowances[msg.sender][spender], addedValue, "Shell/approval-overflow"));
        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(ShellStorage.Shell storage shell, address spender, uint256 subtractedValue) external returns (bool) {
        _approve(shell, msg.sender, spender, sub(shell.allowances[msg.sender][spender], subtractedValue, "Shell/allowance-decrease-underflow"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is public 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(ShellStorage.Shell storage shell, address sender, address recipient, uint256 amount) private {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        shell.balances[sender] = sub(shell.balances[sender], amount, "Shell/insufficient-balance");
        shell.balances[recipient] = add(shell.balances[recipient], amount, "Shell/transfer-overflow");
        emit Transfer(sender, recipient, amount);
    }


    /**
     * @dev Sets `amount` as the allowance of `spender` over the `_owner`s tokens.
     *
     * This is public 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(ShellStorage.Shell storage shell, address _owner, address spender, uint256 amount) private {
        require(_owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        shell.allowances[_owner][spender] = amount;
        emit Approval(_owner, spender, amount);
    }

}
////// src/Swaps.sol
/* pragma solidity ^0.5.0; */

/* import "./Assimilators.sol"; */

/* import "./ShellStorage.sol"; */

/* import "./ShellMath.sol"; */

/* import "./UnsafeMath64x64.sol"; */

/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */

library Swaps {

    using ABDKMath64x64 for int128;
    using UnsafeMath64x64 for int128;

    event Trade(address indexed trader, address indexed origin, address indexed target, uint256 originAmount, uint256 targetAmount);

    int128 constant ONE = 0x10000000000000000;

    function getOriginAndTarget (
        ShellStorage.Shell storage shell,
        address _o,
        address _t
    ) private view returns (
        ShellStorage.Assimilator memory,
        ShellStorage.Assimilator memory
    ) {

        ShellStorage.Assimilator memory o_ = shell.assimilators[_o];
        ShellStorage.Assimilator memory t_ = shell.assimilators[_t];

        require(o_.addr != address(0), "Shell/origin-not-supported");
        require(t_.addr != address(0), "Shell/target-not-supported");

        return ( o_, t_ );

    }


    function originSwap (
        ShellStorage.Shell storage shell,
        address _origin,
        address _target,
        uint256 _originAmount,
        address _recipient
    ) external returns (
        uint256 tAmt_
    ) {

        (   ShellStorage.Assimilator memory _o,
            ShellStorage.Assimilator memory _t  ) = getOriginAndTarget(shell, _origin, _target);

        if (_o.ix == _t.ix) return Assimilators.outputNumeraire(_t.addr, _recipient, Assimilators.intakeRaw(_o.addr, _originAmount));

        (   int128 _amt,
            int128 _oGLiq,
            int128 _nGLiq,
            int128[] memory _oBals,
            int128[] memory _nBals ) = getOriginSwapData(shell, _o.ix, _t.ix, _o.addr, _originAmount);

        _amt = ShellMath.calculateTrade(shell, _oGLiq, _nGLiq, _oBals, _nBals, _amt, _t.ix);

        _amt = _amt.us_mul(ONE - shell.epsilon);

        tAmt_ = Assimilators.outputNumeraire(_t.addr, _recipient, _amt);

        emit Trade(msg.sender, _origin, _target, _originAmount, tAmt_);

    }

    function viewOriginSwap (
        ShellStorage.Shell storage shell,
        address _origin,
        address _target,
        uint256 _originAmount
    ) external view returns (
        uint256 tAmt_
    ) {

        (   ShellStorage.Assimilator memory _o,
            ShellStorage.Assimilator memory _t  ) = getOriginAndTarget(shell, _origin, _target);

        if (_o.ix == _t.ix) return Assimilators.viewRawAmount(_t.addr, Assimilators.viewNumeraireAmount(_o.addr, _originAmount));

        (   int128 _amt,
            int128 _oGLiq,
            int128 _nGLiq,
            int128[] memory _nBals,
            int128[] memory _oBals ) = viewOriginSwapData(shell, _o.ix, _t.ix, _originAmount, _o.addr);

        _amt = ShellMath.calculateTrade(shell, _oGLiq, _nGLiq, _oBals, _nBals, _amt, _t.ix);

        _amt = _amt.us_mul(ONE - shell.epsilon);

        tAmt_ = Assimilators.viewRawAmount(_t.addr, _amt.abs());

    }

    function targetSwap (
        ShellStorage.Shell storage shell,
        address _origin,
        address _target,
        uint256 _targetAmount,
        address _recipient
    ) external returns (
        uint256 oAmt_
    ) {

        (   ShellStorage.Assimilator memory _o,
            ShellStorage.Assimilator memory _t  ) = getOriginAndTarget(shell, _origin, _target);

        if (_o.ix == _t.ix) return Assimilators.intakeNumeraire(_o.addr, Assimilators.outputRaw(_t.addr, _recipient, _targetAmount));

        (   int128 _amt,
            int128 _oGLiq,
            int128 _nGLiq,
            int128[] memory _oBals,
            int128[] memory _nBals) = getTargetSwapData(shell, _t.ix, _o.ix, _t.addr, _recipient, _targetAmount);

        _amt = ShellMath.calculateTrade(shell, _oGLiq, _nGLiq, _oBals, _nBals, _amt, _o.ix);

        _amt = _amt.us_mul(ONE + shell.epsilon);

        oAmt_ = Assimilators.intakeNumeraire(_o.addr, _amt);

        emit Trade(msg.sender, _origin, _target, oAmt_, _targetAmount);

    }

    function viewTargetSwap (
        ShellStorage.Shell storage shell,
        address _origin,
        address _target,
        uint256 _targetAmount
    ) external view returns (
        uint256 oAmt_
    ) {

        (   ShellStorage.Assimilator memory _o,
            ShellStorage.Assimilator memory _t  ) = getOriginAndTarget(shell, _origin, _target);

        if (_o.ix == _t.ix) return Assimilators.viewRawAmount(_o.addr, Assimilators.viewNumeraireAmount(_t.addr, _targetAmount));

        (   int128 _amt,
            int128 _oGLiq,
            int128 _nGLiq,
            int128[] memory _nBals,
            int128[] memory _oBals ) = viewTargetSwapData(shell, _t.ix, _o.ix, _targetAmount, _t.addr);

        _amt = ShellMath.calculateTrade(shell, _oGLiq, _nGLiq, _oBals, _nBals, _amt, _o.ix);

        _amt = _amt.us_mul(ONE + shell.epsilon);

        oAmt_ = Assimilators.viewRawAmount(_o.addr, _amt);

    }

    function getOriginSwapData (
        ShellStorage.Shell storage shell,
        uint _inputIx,
        uint _outputIx,
        address _assim,
        uint _amt
    ) private returns (
        int128 amt_,
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = shell.assets.length;

        int128[] memory oBals_ = new int128[](_length);
        int128[] memory nBals_ = new int128[](_length);
        ShellStorage.Assimilator[] memory _reserves = shell.assets;

        for (uint i = 0; i < _length; i++) {

            if (i != _inputIx) nBals_[i] = oBals_[i] = Assimilators.viewNumeraireBalance(_reserves[i].addr);
            else {

                int128 _bal;
                ( amt_, _bal ) = Assimilators.intakeRawAndGetBalance(_assim, _amt);

                oBals_[i] = _bal.sub(amt_);
                nBals_[i] = _bal;

            }

            oGLiq_ += oBals_[i];
            nGLiq_ += nBals_[i];

        }

        nGLiq_ = nGLiq_.sub(amt_);
        nBals_[_outputIx] = ABDKMath64x64.sub(nBals_[_outputIx], amt_);

        return ( amt_, oGLiq_, nGLiq_, oBals_, nBals_ );

    }

    function getTargetSwapData (
        ShellStorage.Shell storage shell,
        uint _inputIx,
        uint _outputIx,
        address _assim,
        address _recipient,
        uint _amt
    ) private returns (
        int128 amt_,
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = shell.assets.length;

        int128[] memory oBals_ = new int128[](_length);
        int128[] memory nBals_ = new int128[](_length);
        ShellStorage.Assimilator[] memory _reserves = shell.assets;

        for (uint i = 0; i < _length; i++) {

            if (i != _inputIx) nBals_[i] = oBals_[i] = Assimilators.viewNumeraireBalance(_reserves[i].addr);
            else {

                int128 _bal;
                ( amt_, _bal ) = Assimilators.outputRawAndGetBalance(_assim, _recipient, _amt);

                oBals_[i] = _bal.sub(amt_);
                nBals_[i] = _bal;

            }

            oGLiq_ += oBals_[i];
            nGLiq_ += nBals_[i];

        }

        nGLiq_ = nGLiq_.sub(amt_);
        nBals_[_outputIx] = ABDKMath64x64.sub(nBals_[_outputIx], amt_);

        return ( amt_, oGLiq_, nGLiq_, oBals_, nBals_ );

    }

    function viewOriginSwapData (
        ShellStorage.Shell storage shell,
        uint _inputIx,
        uint _outputIx,
        uint _amt,
        address _assim
    ) private view returns (
        int128 amt_,
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = shell.assets.length;
        int128[] memory nBals_ = new int128[](_length);
        int128[] memory oBals_ = new int128[](_length);

        for (uint i = 0; i < _length; i++) {

            if (i != _inputIx) nBals_[i] = oBals_[i] = Assimilators.viewNumeraireBalance(shell.assets[i].addr);
            else {

                int128 _bal;
                ( amt_, _bal ) = Assimilators.viewNumeraireAmountAndBalance(_assim, _amt);

                oBals_[i] = _bal;
                nBals_[i] = _bal.add(amt_);

            }

            oGLiq_ += oBals_[i];
            nGLiq_ += nBals_[i];

        }

        nGLiq_ = nGLiq_.sub(amt_);
        nBals_[_outputIx] = ABDKMath64x64.sub(nBals_[_outputIx], amt_);

        return ( amt_, oGLiq_, nGLiq_, nBals_, oBals_ );

    }

    function viewTargetSwapData (
        ShellStorage.Shell storage shell,
        uint _inputIx,
        uint _outputIx,
        uint _amt,
        address _assim
    ) private view returns (
        int128 amt_,
        int128 oGLiq_,
        int128 nGLiq_,
        int128[] memory,
        int128[] memory
    ) {

        uint _length = shell.assets.length;
        int128[] memory nBals_ = new int128[](_length);
        int128[] memory oBals_ = new int128[](_length);

        for (uint i = 0; i < _length; i++) {

            if (i != _inputIx) nBals_[i] = oBals_[i] = Assimilators.viewNumeraireBalance(shell.assets[i].addr);
            else {

                int128 _bal;
                ( amt_, _bal ) = Assimilators.viewNumeraireAmountAndBalance(_assim, _amt);
                amt_ = amt_.neg();

                oBals_[i] = _bal;
                nBals_[i] = _bal.add(amt_);

            }

            oGLiq_ += oBals_[i];
            nGLiq_ += nBals_[i];

        }

        nGLiq_ = nGLiq_.sub(amt_);
        nBals_[_outputIx] = ABDKMath64x64.sub(nBals_[_outputIx], amt_);


        return ( amt_, oGLiq_, nGLiq_, nBals_, oBals_ );

    }

}
////// src/ViewLiquidity.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.


/* pragma solidity ^0.5.0; */

/* import "./ShellStorage.sol"; */

/* import "./Assimilators.sol"; */

/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */

library ViewLiquidity {

    using ABDKMath64x64 for int128;

    function viewLiquidity (
        ShellStorage.Shell storage shell
    ) external view returns (
        uint total_,
        uint[] memory individual_
    ) {

        uint _length = shell.assets.length;

        uint[] memory individual_ = new uint[](_length);
        uint total_;

        for (uint i = 0; i < _length; i++) {

            uint _liquidity = Assimilators.viewNumeraireBalance(shell.assets[i].addr).mulu(1e18);

            total_ += _liquidity;
            individual_[i] = _liquidity;

        }

        return (total_, individual_);

    }

}
////// src/ShellStorage.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/* pragma solidity ^0.5.0; */

/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */

/* import "./Orchestrator.sol"; */

/* import "./PartitionedLiquidity.sol"; */

/* import "./ProportionalLiquidity.sol"; */

/* import "./SelectiveLiquidity.sol"; */

/* import "./Shells.sol"; */

/* import "./Swaps.sol"; */

/* import "./ViewLiquidity.sol"; */

contract ShellStorage {

    address public owner;

    string  public constant name = "Shells";
    string  public constant symbol = "SHL";
    uint8   public constant decimals = 18;

    Shell public shell;

    struct Shell {
        int128 alpha;
        int128 beta;
        int128 delta;
        int128 epsilon;
        int128 lambda;
        int128[] weights;
        uint totalSupply;
        Assimilator[] assets;
        mapping (address => Assimilator) assimilators;
        mapping (address => uint) balances;
        mapping (address => mapping (address => uint)) allowances;
    }

    struct Assimilator {
        address addr;
        uint8 ix;
    }

    mapping (address => PartitionTicket) public partitionTickets;

    struct PartitionTicket {
        uint[] claims;
        bool initialized;
    }

    address[] public derivatives;
    address[] public numeraires;
    address[] public reserves;

    bool public partitioned = false;

    bool public frozen = false;

    bool internal notEntered = true;

}
////// src/ShellMath.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/* pragma solidity ^0.5.0; */

/* import "./Assimilators.sol"; */

/* import "./UnsafeMath64x64.sol"; */

/* import "./ShellStorage.sol"; */

/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */

library ShellMath {

    int128 constant ONE = 0x10000000000000000;
    int128 constant MAX = 0x4000000000000000; // .25 in layman's terms
    int128 constant MAX_DIFF = -0x10C6F7A0B5EE;
    int128 constant ONE_WEI = 0x12;

    using ABDKMath64x64 for int128;
    using UnsafeMath64x64 for int128;
    using ABDKMath64x64 for uint256;

    function calculateFee (
        int128 _gLiq,
        int128[] memory _bals,
        int128 _beta,
        int128 _delta,
        int128[] memory _weights
    ) internal pure returns (int128 psi_) {

        uint _length = _bals.length;

        for (uint i = 0; i < _length; i++) {

            int128 _ideal = _gLiq.us_mul(_weights[i]);

            psi_ += calculateMicroFee(_bals[i], _ideal, _beta, _delta);

        }

    }

    function calculateMicroFee (
        int128 _bal,
        int128 _ideal,
        int128 _beta,
        int128 _delta
    ) private pure returns (int128 fee_) {

        if (_bal < _ideal) {

            int128 _threshold = _ideal.us_mul(ONE - _beta);

            if (_bal < _threshold) {

                int128 _feeMargin = _threshold - _bal;

                fee_ = _feeMargin.us_div(_ideal);
                fee_ = fee_.us_mul(_delta);

                if (fee_ > MAX) fee_ = MAX;

                fee_ = fee_.us_mul(_feeMargin);

            } else fee_ = 0;

        } else {

            int128 _threshold = _ideal.us_mul(ONE + _beta);

            if (_bal > _threshold) {

                int128 _feeMargin = _bal - _threshold;

                fee_ = _feeMargin.us_div(_ideal);
                fee_ = fee_.us_mul(_delta);

                if (fee_ > MAX) fee_ = MAX;

                fee_ = fee_.us_mul(_feeMargin);

            } else fee_ = 0;

        }

    }

    function calculateTrade (
        ShellStorage.Shell storage shell,
        int128 _oGLiq,
        int128 _nGLiq,
        int128[] memory _oBals,
        int128[] memory _nBals,
        int128 _inputAmt,
        uint _outputIndex
    ) internal view returns (int128 outputAmt_) {

        outputAmt_ = - _inputAmt;

        int128 _lambda = shell.lambda;
        int128 _beta = shell.beta;
        int128 _delta = shell.delta;
        int128[] memory _weights = shell.weights;

        int128 _omega = calculateFee(_oGLiq, _oBals, _beta, _delta, _weights);
        int128 _psi;

        for (uint i = 0; i < 32; i++) {

            _psi = calculateFee(_nGLiq, _nBals, _beta, _delta, _weights);

            if (( outputAmt_ = _omega < _psi
                    ? - ( _inputAmt + _omega - _psi )
                    : - ( _inputAmt + _lambda.us_mul(_omega - _psi) )
                ) / 1e13 == outputAmt_ / 1e13 ) {

                _nGLiq = _oGLiq + _inputAmt + outputAmt_;

                _nBals[_outputIndex] = _oBals[_outputIndex] + outputAmt_;

                enforceHalts(shell, _oGLiq, _nGLiq, _oBals, _nBals, _weights);
                
                enforceSwapInvariant(_oGLiq, _omega, _nGLiq, _psi);

                return outputAmt_;

            } else {

                _nGLiq = _oGLiq + _inputAmt + outputAmt_;

                _nBals[_outputIndex] = _oBals[_outputIndex].add(outputAmt_);

            }

        }

        revert("Shell/swap-convergence-failed");

    }
    
    function enforceSwapInvariant (
        int128 _oGLiq,
        int128 _omega,
        int128 _nGLiq,
        int128 _psi
    ) private pure {

        int128 _nextUtil = _nGLiq - _psi;

        int128 _prevUtil = _oGLiq - _omega;

        int128 _diff = _nextUtil - _prevUtil;

        require(0 < _diff || _diff >= MAX_DIFF, "Shell/swap-invariant-violation");
        
    }

    function calculateLiquidityMembrane (
        ShellStorage.Shell storage shell,
        int128 _oGLiq,
        int128 _nGLiq,
        int128[] memory _oBals,
        int128[] memory _nBals
    ) internal view returns (int128 shells_) {

        enforceHalts(shell, _oGLiq, _nGLiq, _oBals, _nBals, shell.weights);
        
        int128 _omega;
        int128 _psi;
        
        {
            
            int128 _beta = shell.beta;
            int128 _delta = shell.delta;
            int128[] memory _weights = shell.weights;

            _omega = calculateFee(_oGLiq, _oBals, _beta, _delta, _weights);
            _psi = calculateFee(_nGLiq, _nBals, _beta, _delta, _weights);

        }

        int128 _feeDiff = _psi.sub(_omega);
        int128 _liqDiff = _nGLiq.sub(_oGLiq);
        int128 _oUtil = _oGLiq.sub(_omega);
        int128 _totalShells = shell.totalSupply.divu(1e18);
        int128 _shellMultiplier;

        if (_totalShells == 0) {

            shells_ = _nGLiq.sub(_psi);

        } else if (_feeDiff >= 0) {

            _shellMultiplier = _liqDiff.sub(_feeDiff).div(_oUtil);

        } else {
            
            _shellMultiplier = _liqDiff.sub(shell.lambda.mul(_feeDiff));
            
            _shellMultiplier = _shellMultiplier.div(_oUtil);

        }

        if (_totalShells != 0) {

            shells_ = _totalShells.us_mul(_shellMultiplier);
            
            enforceLiquidityInvariant(_totalShells, shells_, _oGLiq, _nGLiq, _omega, _psi);

        }

    }
    
    function enforceLiquidityInvariant (
        int128 _totalShells,
        int128 _newShells,
        int128 _oGLiq,
        int128 _nGLiq,
        int128 _omega,
        int128 _psi
    ) internal view {
        
        if (_totalShells == 0 || 0 == _totalShells + _newShells) return;
        
        int128 _prevUtilPerShell = _oGLiq
            .sub(_omega)
            .div(_totalShells);
            
        int128 _nextUtilPerShell = _nGLiq
            .sub(_psi)
            .div(_totalShells.add(_newShells));

        int128 _diff = _nextUtilPerShell - _prevUtilPerShell;

        require(0 < _diff || _diff >= MAX_DIFF, "Shell/liquidity-invariant-violation");
        
    }

    function enforceHalts (
        ShellStorage.Shell storage shell,
        int128 _oGLiq,
        int128 _nGLiq,
        int128[] memory _oBals,
        int128[] memory _nBals,
        int128[] memory _weights
    ) private view {

        uint256 _length = _nBals.length;
        int128 _alpha = shell.alpha;

        for (uint i = 0; i < _length; i++) {

            int128 _nIdeal = _nGLiq.us_mul(_weights[i]);

            if (_nBals[i] > _nIdeal) {

                int128 _upperAlpha = ONE + _alpha;

                int128 _nHalt = _nIdeal.us_mul(_upperAlpha);

                if (_nBals[i] > _nHalt){

                    int128 _oHalt = _oGLiq.us_mul(_weights[i]).us_mul(_upperAlpha);

                    if (_oBals[i] < _oHalt) revert("Shell/upper-halt");
                    if (_nBals[i] - _nHalt > _oBals[i] - _oHalt) revert("Shell/upper-halt");

                }

            } else {

                int128 _lowerAlpha = ONE - _alpha;

                int128 _nHalt = _nIdeal.us_mul(_lowerAlpha);

                if (_nBals[i] < _nHalt){

                    int128 _oHalt = _oGLiq.us_mul(_weights[i]).us_mul(_lowerAlpha);

                    if (_oBals[i] > _oHalt) revert("Shell/lower-halt");
                    if (_nHalt - _nBals[i] > _oHalt - _oBals[i]) revert("Shell/lower-halt");

                }
            }
        }
    }
}
////// src/Orchestrator.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/* pragma solidity ^0.5.0; */

/* import "./Assimilators.sol"; */

/* import "./ShellMath.sol"; */

/* import "./ShellStorage.sol"; */

/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */

library Orchestrator {

    using ABDKMath64x64 for int128;
    using ABDKMath64x64 for uint256;

    int128 constant ONE_WEI = 0x12;

    event ParametersSet(uint256 alpha, uint256 beta, uint256 delta, uint256 epsilon, uint256 lambda);

    event AssetIncluded(address indexed numeraire, address indexed reserve, uint weight);

    event AssimilatorIncluded(address indexed derivative, address indexed numeraire, address indexed reserve, address assimilator);

    function setParams (
        ShellStorage.Shell storage shell,
        uint256 _alpha,
        uint256 _beta,
        uint256 _feeAtHalt,
        uint256 _epsilon,
        uint256 _lambda
    ) external {

        require(0 < _alpha && _alpha < 1e18, "Shell/parameter-invalid-alpha");

        require(0 <= _beta && _beta < _alpha, "Shell/parameter-invalid-beta");

        require(_feeAtHalt <= .5e18, "Shell/parameter-invalid-max");

        require(0 <= _epsilon && _epsilon <= .01e18, "Shell/parameter-invalid-epsilon");

        require(0 <= _lambda && _lambda <= 1e18, "Shell/parameter-invalid-lambda");

        int128 _omega = getFee(shell);

        shell.alpha = (_alpha + 1).divu(1e18);

        shell.beta = (_beta + 1).divu(1e18);

        shell.delta = ( _feeAtHalt ).divu(1e18).div(uint(2).fromUInt().mul(shell.alpha.sub(shell.beta))) + ONE_WEI;

        shell.epsilon = (_epsilon + 1).divu(1e18);

        shell.lambda = (_lambda + 1).divu(1e18);
        
        int128 _psi = getFee(shell);
        
        require(_omega >= _psi, "Shell/parameters-increase-fee");

        emit ParametersSet(_alpha, _beta, shell.delta.mulu(1e18), _epsilon, _lambda);

    }

    function getFee (
        ShellStorage.Shell storage shell
    ) private view returns (
        int128 fee_
    ) {

        int128 _gLiq;

        int128[] memory _bals = new int128[](shell.assets.length);

        for (uint i = 0; i < _bals.length; i++) {

            int128 _bal = Assimilators.viewNumeraireBalance(shell.assets[i].addr);

            _bals[i] = _bal;

            _gLiq += _bal;

        }

        fee_ = ShellMath.calculateFee(_gLiq, _bals, shell.beta, shell.delta, shell.weights);

    }
    
 
    function initialize (
        ShellStorage.Shell storage shell,
        address[] storage numeraires,
        address[] storage reserves,
        address[] storage derivatives,
        address[] calldata _assets,
        uint[] calldata _assetWeights,
        address[] calldata _derivativeAssimilators
    ) external {
        
        for (uint i = 0; i < _assetWeights.length; i++) {

            uint ix = i*5;
        
            numeraires.push(_assets[ix]);
            derivatives.push(_assets[ix]);

            reserves.push(_assets[2+ix]);
            if (_assets[ix] != _assets[2+ix]) derivatives.push(_assets[2+ix]);
            
            includeAsset(
                shell,
                _assets[ix],   // numeraire
                _assets[1+ix], // numeraire assimilator
                _assets[2+ix], // reserve
                _assets[3+ix], // reserve assimilator
                _assets[4+ix], // reserve approve to
                _assetWeights[i]
            );
            
        }
        
        for (uint i = 0; i < _derivativeAssimilators.length / 5; i++) {
            
            uint ix = i * 5;

            derivatives.push(_derivativeAssimilators[ix]);

            includeAssimilator(
                shell,
                _derivativeAssimilators[ix],   // derivative
                _derivativeAssimilators[1+ix], // numeraire
                _derivativeAssimilators[2+ix], // reserve
                _derivativeAssimilators[3+ix], // assimilator
                _derivativeAssimilators[4+ix]  // derivative approve to
            );

        }

    }

    function includeAsset (
        ShellStorage.Shell storage shell,
        address _numeraire,
        address _numeraireAssim,
        address _reserve,
        address _reserveAssim,
        address _reserveApproveTo,
        uint256 _weight
    ) private {

        require(_numeraire != address(0), "Shell/numeraire-cannot-be-zeroth-adress");

        require(_numeraireAssim != address(0), "Shell/numeraire-assimilator-cannot-be-zeroth-adress");

        require(_reserve != address(0), "Shell/reserve-cannot-be-zeroth-adress");

        require(_reserveAssim != address(0), "Shell/reserve-assimilator-cannot-be-zeroth-adress");

        require(_weight < 1e18, "Shell/weight-must-be-less-than-one");

        if (_numeraire != _reserve) safeApprove(_numeraire, _reserveApproveTo, uint(-1));

        ShellStorage.Assimilator storage _numeraireAssimilator = shell.assimilators[_numeraire];

        _numeraireAssimilator.addr = _numeraireAssim;

        _numeraireAssimilator.ix = uint8(shell.assets.length);

        ShellStorage.Assimilator storage _reserveAssimilator = shell.assimilators[_reserve];

        _reserveAssimilator.addr = _reserveAssim;

        _reserveAssimilator.ix = uint8(shell.assets.length);

        int128 __weight = _weight.divu(1e18).add(uint256(1).divu(1e18));

        shell.weights.push(__weight);

        shell.assets.push(_numeraireAssimilator);

        emit AssetIncluded(_numeraire, _reserve, _weight);

        emit AssimilatorIncluded(_numeraire, _numeraire, _reserve, _numeraireAssim);

        if (_numeraireAssim != _reserveAssim) {

            emit AssimilatorIncluded(_reserve, _numeraire, _reserve, _reserveAssim);

        }

    }
    
    function includeAssimilator (
        ShellStorage.Shell storage shell,
        address _derivative,
        address _numeraire,
        address _reserve,
        address _assimilator,
        address _derivativeApproveTo
    ) private {

        require(_derivative != address(0), "Shell/derivative-cannot-be-zeroth-address");

        require(_numeraire != address(0), "Shell/numeraire-cannot-be-zeroth-address");

        require(_reserve != address(0), "Shell/numeraire-cannot-be-zeroth-address");

        require(_assimilator != address(0), "Shell/assimilator-cannot-be-zeroth-address");
        
        safeApprove(_numeraire, _derivativeApproveTo, uint(-1));

        ShellStorage.Assimilator storage _numeraireAssim = shell.assimilators[_numeraire];

        shell.assimilators[_derivative] = ShellStorage.Assimilator(_assimilator, _numeraireAssim.ix);

        emit AssimilatorIncluded(_derivative, _numeraire, _reserve, _assimilator);

    }

    function safeApprove (
        address _token,
        address _spender,
        uint256 _value
    ) private {

        ( bool success, bytes memory returndata ) = _token.call(abi.encodeWithSignature("approve(address,uint256)", _spender, _value));

        require(success, "SafeERC20: low-level call failed");

    }

    function viewShell (
        ShellStorage.Shell storage shell
    ) external view returns (
        uint alpha_,
        uint beta_,
        uint delta_,
        uint epsilon_,
        uint lambda_
    ) {

        alpha_ = shell.alpha.mulu(1e18);

        beta_ = shell.beta.mulu(1e18);

        delta_ = shell.delta.mulu(1e18);

        epsilon_ = shell.epsilon.mulu(1e18);

        lambda_ = shell.lambda.mulu(1e18);

    }

}
////// src/interfaces/IFreeFromUpTo.sol
/* pragma solidity ^0.5.0; */

interface IFreeFromUpTo {
    function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);
}

////// src/Shell.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/* pragma solidity ^0.5.0; */

/* import "abdk-libraries-solidity/ABDKMath64x64.sol"; */

/* import "./Orchestrator.sol"; */

/* import "./PartitionedLiquidity.sol"; */

/* import "./ProportionalLiquidity.sol"; */

/* import "./SelectiveLiquidity.sol"; */

/* import "./Shells.sol"; */

/* import "./Swaps.sol"; */

/* import "./ViewLiquidity.sol"; */

/* import "./ShellStorage.sol"; */

/* import "./interfaces/IFreeFromUpTo.sol"; */

contract Shell is ShellStorage {

    event Approval(address indexed _owner, address indexed spender, uint256 value);

    event ParametersSet(uint256 alpha, uint256 beta, uint256 delta, uint256 epsilon, uint256 lambda);

    event AssetIncluded(address indexed numeraire, address indexed reserve, uint weight);

    event AssimilatorIncluded(address indexed derivative, address indexed numeraire, address indexed reserve, address assimilator);

    event PartitionRedeemed(address indexed token, address indexed redeemer, uint value);

    event PoolPartitioned(bool partitioned);

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

    event FrozenSet(bool isFrozen);

    event Trade(address indexed trader, address indexed origin, address indexed target, uint256 originAmount, uint256 targetAmount);

    event Transfer(address indexed from, address indexed to, uint256 value);

    IFreeFromUpTo public constant chi = IFreeFromUpTo(0x0000000000004946c0e9F43F4Dee607b0eF1fA1c);

    modifier discountCHI {
        uint256 gasStart = gasleft();
        _;
        uint256 gasSpent = 21000 + gasStart - gasleft() + 16 * msg.data.length;
        chi.freeFromUpTo(msg.sender, (gasSpent + 14154) / 41130);
    }

    modifier onlyOwner() {

        require(msg.sender == owner, "Shell/caller-is-not-owner");
        _;

    }

    modifier nonReentrant() {

        require(notEntered, "Shell/re-entered");
        notEntered = false;
        _;
        notEntered = true;

    }

    modifier transactable () {

        require(!frozen, "Shell/frozen-only-allowing-proportional-withdraw");
        _;

    }

    modifier unpartitioned () {

        require(!partitioned, "Shell/pool-partitioned");
        _;

    }

    modifier isPartitioned () {

        require(partitioned, "Shell/pool-not-partitioned");
        _;

    }

    modifier deadline (uint _deadline) {

        require(block.timestamp < _deadline, "Shell/tx-deadline-passed");
        _;

    }

    constructor (
        address[] memory _assets,
        uint[] memory _assetWeights,
        address[] memory _derivativeAssimilators
    ) public {
        
        owner = msg.sender;
        emit OwnershipTransfered(address(0), msg.sender);
        
        Orchestrator.initialize(
            shell,
            numeraires,
            reserves,
            derivatives,
            _assets,
            _assetWeights,
            _derivativeAssimilators
        );

    }

    /// @notice sets the parameters for the pool
    /// @param _alpha the value for alpha (halt threshold) must be less than or equal to 1 and greater than 0
    /// @param _beta the value for beta must be less than alpha and greater than 0
    /// @param _feeAtHalt the maximum value for the fee at the halt point
    /// @param _epsilon the base fee for the pool
    /// @param _lambda the value for lambda must be less than or equal to 1 and greater than zero
    function setParams (
        uint _alpha,
        uint _beta, 
        uint _feeAtHalt,
        uint _epsilon,
        uint _lambda
    ) external onlyOwner {

        Orchestrator.setParams(shell, _alpha, _beta, _feeAtHalt, _epsilon, _lambda);

    }

    /// @notice excludes an assimilator from the shell
    /// @param _derivative the address of the assimilator to exclude
    function excludeDerivative (
        address _derivative
    ) external onlyOwner {

        uint _length = numeraires.length; 

        for (uint i = 0; i < numeraires.length; i++) {
            
            if (_derivative == numeraires[i]) revert("Shell/cannot-delete-numeraire");
            if (_derivative == reserves[i]) revert("Shell/cannot-delete-reserve");
            
        }

        delete shell.assimilators[_derivative];

    }

    /// @notice view the current parameters of the shell
    /// @return alpha_ the current alpha value
    /// @return beta_ the current beta value
    /// @return delta_ the current delta value
    /// @return epsilon_ the current epsilon value
    /// @return lambda_ the current lambda value
    /// @return omega_ the current omega value
    function viewShell () external view returns (
        uint alpha_,
        uint beta_,
        uint delta_,
        uint epsilon_,
        uint lambda_
    ) {

        return Orchestrator.viewShell(shell);

    }

    function setFrozen (bool _toFreezeOrNotToFreeze) external onlyOwner {

        emit FrozenSet(_toFreezeOrNotToFreeze);

        frozen = _toFreezeOrNotToFreeze;

    }

    function transferOwnership (address _newOwner) external onlyOwner {

        emit OwnershipTransfered(owner, _newOwner);

        owner = _newOwner;

    }

    /// @author james foley http://github.com/realisation
    /// @notice swap a dynamic origin amount for a fixed target amount
    /// @param _origin the address of the origin
    /// @param _target the address of the target
    /// @param _originAmount the origin amount
    /// @param _minTargetAmount the minimum target amount
    /// @param _deadline deadline in block number after which the trade will not execute
    /// @return targetAmount_ the amount of target that has been swapped for the origin amount
    function originSwap (
        address _origin,
        address _target,
        uint _originAmount,
        uint _minTargetAmount,
        uint _deadline
    ) external deadline(_deadline) transactable nonReentrant returns (
        uint targetAmount_
    ) {

        targetAmount_ = Swaps.originSwap(shell, _origin, _target, _originAmount, msg.sender);

        require(targetAmount_ > _minTargetAmount, "Shell/below-min-target-amount");

    }

    function originSwapDiscountCHI (
        address _origin,
        address _target,
        uint _originAmount,
        uint _minTargetAmount,
        uint _deadline
    ) external deadline(_deadline) transactable nonReentrant discountCHI returns (
        uint targetAmount_
    ) {

        targetAmount_ = Swaps.originSwap(shell, _origin, _target, _originAmount, msg.sender);

        require(targetAmount_ > _minTargetAmount, "Shell/below-min-target-amount");

    }

    /// @author james foley http://github.com/realisation
    /// @notice view how much target amount a fixed origin amount will swap for
    /// @param _origin the address of the origin
    /// @param _target the address of the target
    /// @param _originAmount the origin amount
    /// @return targetAmount_ the target amount that would have been swapped for the origin amount
    function viewOriginSwap (
        address _origin,
        address _target,
        uint _originAmount
    ) external view transactable returns (
        uint targetAmount_
    ) {

        targetAmount_ = Swaps.viewOriginSwap(shell, _origin, _target, _originAmount);

    }

    /// @author james foley http://github.com/realisation
    /// @notice swap a dynamic origin amount for a fixed target amount
    /// @param _origin the address of the origin
    /// @param _target the address of the target
    /// @param _maxOriginAmount the maximum origin amount
    /// @param _targetAmount the target amount
    /// @param _deadline deadline in block number after which the trade will not execute
    /// @return originAmount_ the amount of origin that has been swapped for the target
    function targetSwap (
        address _origin,
        address _target,
        uint _maxOriginAmount,
        uint _targetAmount,
        uint _deadline
    ) external deadline(_deadline) transactable nonReentrant returns (
        uint originAmount_
    ) {

        originAmount_ = Swaps.targetSwap(shell, _origin, _target, _targetAmount, msg.sender);

        require(originAmount_ < _maxOriginAmount, "Shell/above-max-origin-amount");

    }

    /// @author james foley http://github.com/realisation
    /// @notice view how much of the origin currency the target currency will take
    /// @param _origin the address of the origin
    /// @param _target the address of the target
    /// @param _targetAmount the target amount
    /// @return originAmount_ the amount of target that has been swapped for the origin
    function viewTargetSwap (
        address _origin,
        address _target,
        uint _targetAmount
    ) external view transactable returns (
        uint originAmount_
    ) {

        originAmount_ = Swaps.viewTargetSwap(shell, _origin, _target, _targetAmount);

    }

    /// @author james foley http://github.com/realisation
    /// @notice selectively deposit any supported stablecoin flavor into the contract in return for corresponding amount of shell tokens
    /// @param _derivatives an array containing the addresses of the flavors being deposited into
    /// @param _amounts an array containing the values of the flavors you wish to deposit into the contract. each amount should have the same index as the flavor it is meant to deposit
    /// @param _minShells minimum acceptable amount of shells
    /// @param _deadline deadline for tx
    /// @return shellsToMint_ the amount of shells to mint for the deposited stablecoin flavors
    function selectiveDeposit (
        address[] calldata _derivatives,
        uint[] calldata _amounts,
        uint _minShells,
        uint _deadline
    ) external deadline(_deadline) transactable nonReentrant returns (
        uint shellsMinted_
    ) {

        shellsMinted_ = SelectiveLiquidity.selectiveDeposit(shell, _derivatives, _amounts, _minShells);

    }

    /// @author james folew http://github.com/realisation
    /// @notice view how many shell tokens a deposit will mint
    /// @param _derivatives an array containing the addresses of the flavors being deposited into
    /// @param _amounts an array containing the values of the flavors you wish to deposit into the contract. each amount should have the same index as the flavor it is meant to deposit
    /// @return shellsToMint_ the amount of shells to mint for the deposited stablecoin flavors
    function viewSelectiveDeposit (
        address[] calldata _derivatives,
        uint[] calldata _amounts
    ) external view transactable returns (
        uint shellsToMint_
    ) {

        shellsToMint_ = SelectiveLiquidity.viewSelectiveDeposit(shell, _derivatives, _amounts);

    }

    /// @author james foley http://github.com/realisation
    /// @notice deposit into the pool with no slippage from the numeraire assets the pool supports
    /// @param  _deposit the full amount you want to deposit into the pool which will be divided up evenly amongst the numeraire assets of the pool
    /// @return shellsToMint_ the amount of shells you receive in return for your deposit
    /// @return deposits_ the amount deposited for each numeraire
    function proportionalDeposit (
        uint _deposit,
        uint _deadline
    ) external deadline(_deadline) transactable nonReentrant returns (
        uint shellsMinted_,
        uint[] memory deposits_
    ) {

        return ProportionalLiquidity.proportionalDeposit(shell, _deposit);

    }

    /// @author james foley http://github.com/realisation
    /// @notice view deposits and shells minted a given deposit would return
    /// @param _deposit the full amount of stablecoins you want to deposit. Divided evenly according to the prevailing proportions of the numeraire assets of the pool
    /// @return shellsToMint_ the amount of shells you receive in return for your deposit
    /// @return deposits_ the amount deposited for each numeraire
    function viewProportionalDeposit (
        uint _deposit
    ) external view transactable returns (
        uint shellsToMint_,
        uint[] memory depositsToMake_
    ) {

        return ProportionalLiquidity.viewProportionalDeposit(shell, _deposit);

    }

    /// @author james foley http://github.com/realisation
    /// @notice selectively withdrawal any supported stablecoin flavor from the contract by burning a corresponding amount of shell tokens
    /// @param _derivatives an array of flavors to withdraw from the reserves
    /// @param _amounts an array of amounts to withdraw that maps to _flavors
    /// @param _maxShells the maximum amount of shells you want to burn
    /// @param _deadline timestamp after which the transaction is no longer valid
    /// @return shellsBurned_ the corresponding amount of shell tokens to withdraw the specified amount of specified flavors
    function selectiveWithdraw (
        address[] calldata _derivatives,
        uint[] calldata _amounts,
        uint _maxShells,
        uint _deadline
    ) external deadline(_deadline) transactable nonReentrant returns (
        uint shellsBurned_
    ) {

        shellsBurned_ = SelectiveLiquidity.selectiveWithdraw(shell, _derivatives, _amounts, _maxShells);

    }

    /// @author james foley http://github.com/realisation
    /// @notice view how many shell tokens a withdraw will consume
    /// @param _derivatives an array of flavors to withdraw from the reserves
    /// @param _amounts an array of amounts to withdraw that maps to _flavors
    /// @return shellsBurned_ the corresponding amount of shell tokens to withdraw the specified amount of specified flavors
    function viewSelectiveWithdraw (
        address[] calldata _derivatives,
        uint[] calldata _amounts
    ) external view transactable returns (
        uint shellsToBurn_
    ) {

        shellsToBurn_ = SelectiveLiquidity.viewSelectiveWithdraw(shell, _derivatives, _amounts);

    }

    /// @author  james foley http://github.com/realisation
    /// @notice  withdrawas amount of shell tokens from the the pool equally from the numeraire assets of the pool with no slippage
    /// @param   _shellsToBurn the full amount you want to withdraw from the pool which will be withdrawn from evenly amongst the numeraire assets of the pool
    /// @return withdrawals_ the amonts of numeraire assets withdrawn from the pool
    function proportionalWithdraw (
        uint _shellsToBurn,
        uint _deadline
    ) external deadline(_deadline) unpartitioned nonReentrant returns (
        uint[] memory withdrawals_
    ) {

        return ProportionalLiquidity.proportionalWithdraw(shell, _shellsToBurn);

    }

    function supportsInterface (
        bytes4 _interface
    ) public view returns (
        bool supports_
    ) { 

        supports_ = this.supportsInterface.selector == _interface  // erc165
            || bytes4(0x7f5828d0) == _interface                   // eip173
            || bytes4(0x36372b07) == _interface;                 // erc20
        
    }

    /// @author  james foley http://github.com/realisation
    /// @notice  withdrawals amount of shell tokens from the the pool equally from the numeraire assets of the pool with no slippage
    /// @param   _shellsToBurn the full amount you want to withdraw from the pool which will be withdrawn from evenly amongst the numeraire assets of the pool
    /// @return withdrawalsToHappen_ the amonts of numeraire assets withdrawn from the pool
    function viewProportionalWithdraw (
        uint _shellsToBurn
    ) external view unpartitioned returns (
        uint[] memory withdrawalsToHappen_
    ) {

        return ProportionalLiquidity.viewProportionalWithdraw(shell, _shellsToBurn);

    }

    function partition () external onlyOwner {

        require(frozen, "Shell/must-be-frozen");

        PartitionedLiquidity.partition(shell, partitionTickets);

        partitioned = true;

    }
    
    /// @author  james foley http://github.com/realisation
    /// @notice  withdraws amount of shell tokens from the the pool equally from the numeraire assets of the pool with no slippage
    /// @param _tokens an array of the numeraire assets you will withdraw
    /// @param _amounts an array of the amounts in terms of partitioned shels you want to withdraw from that numeraire partition
    /// @return withdrawals_ the amounts of the numeraire assets withdrawn
    function partitionedWithdraw (
        address[] calldata _tokens,
        uint256[] calldata _amounts
    ) external isPartitioned returns (
        uint256[] memory withdrawals_
    ) {

        return PartitionedLiquidity.partitionedWithdraw(shell, partitionTickets, _tokens, _amounts);

    }

    /// @author  james foley http://github.com/realisation
    /// @notice  views the balance of the users partition ticket
    /// @param _addr the address whose balances in partitioned shells to be seen
    /// @return claims_ the remaining claims in terms of partitioned shells the address has in its partition ticket
    function viewPartitionClaims (
        address _addr
    ) external view isPartitioned returns (
        uint[] memory claims_
    ) {

        return PartitionedLiquidity.viewPartitionClaims(shell, partitionTickets, _addr);

    }

    /// @notice transfers shell tokens
    /// @param _recipient the address of where to send the shell tokens
    /// @param _amount the amount of shell tokens to send
    /// @return success_ the success bool of the call
    function transfer (
        address _recipient,
        uint _amount
    ) public nonReentrant returns (
        bool success_
    ) {

        require(!partitionTickets[msg.sender].initialized, "Shell/no-transfers-once-partitioned");

        success_ = Shells.transfer(shell, _recipient, _amount);

    }

    /// @notice transfers shell tokens from one address to another address
    /// @param _sender the account from which the shell tokens will be sent
    /// @param _recipient the account to which the shell tokens will be sent
    /// @param _amount the amount of shell tokens to transfer
    /// @return success_ the success bool of the call
    function transferFrom (
        address _sender,
        address _recipient,
        uint _amount
    ) public nonReentrant returns (
        bool success_
    ) {

        require(!partitionTickets[_sender].initialized, "Shell/no-transfers-once-partitioned");

        success_ = Shells.transferFrom(shell, _sender, _recipient, _amount);

    }

    /// @notice approves a user to spend shell tokens on their behalf
    /// @param _spender the account to allow to spend from msg.sender
    /// @param _amount the amount to specify the spender can spend
    /// @return success_ the success bool of this call
    function approve (address _spender, uint _amount) public nonReentrant returns (bool success_) {

        success_ = Shells.approve(shell, _spender, _amount);

    }

    /// @notice view the shell token balance of a given account
    /// @param _account the account to view the balance of  
    /// @return balance_ the shell token ballance of the given account
    function balanceOf (
        address _account
    ) public view returns (
        uint balance_
    ) {

        balance_ = shell.balances[_account];

    }

    /// @notice views the total shell supply of the pool
    /// @return totalSupply_ the total supply of shell tokens
    function totalSupply () public view returns (uint totalSupply_) {

        totalSupply_ = shell.totalSupply;

    }

    /// @notice views the total allowance one address has to spend from another address
    /// @param _owner the address of the owner 
    /// @param _spender the address of the spender
    /// @return allowance_ the amount the owner has allotted the spender
    function allowance (
        address _owner,
        address _spender
    ) public view returns (
        uint allowance_
    ) {

        allowance_ = shell.allowances[_owner][_spender];

    }

    /// @notice views the total amount of liquidity in the shell in numeraire value and format - 18 decimals
    /// @return total_ the total value in the shell
    /// @return individual_ the individual values in the shell
    function liquidity () public view returns (
        uint total_,
        uint[] memory individual_
    ) {

        return ViewLiquidity.viewLiquidity(shell);

    }
    
    /// @notice view the assimilator address for a derivative
    /// @return assimilator_ the assimilator address
    function assimilator (
        address _derivative
    ) public view returns (
        address assimilator_
    ) {

        assimilator_ = shell.assimilators[_derivative].addr;

    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address[]","name":"_assets","type":"address[]"},{"internalType":"uint256[]","name":"_assetWeights","type":"uint256[]"},{"internalType":"address[]","name":"_derivativeAssimilators","type":"address[]"}],"payable":false,"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":"numeraire","type":"address"},{"indexed":true,"internalType":"address","name":"reserve","type":"address"},{"indexed":false,"internalType":"uint256","name":"weight","type":"uint256"}],"name":"AssetIncluded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"derivative","type":"address"},{"indexed":true,"internalType":"address","name":"numeraire","type":"address"},{"indexed":true,"internalType":"address","name":"reserve","type":"address"},{"indexed":false,"internalType":"address","name":"assimilator","type":"address"}],"name":"AssimilatorIncluded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"isFrozen","type":"bool"}],"name":"FrozenSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransfered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"alpha","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"beta","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"delta","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"epsilon","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lambda","type":"uint256"}],"name":"ParametersSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"redeemer","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"PartitionRedeemed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"partitioned","type":"bool"}],"name":"PoolPartitioned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":true,"internalType":"address","name":"origin","type":"address"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"originAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"targetAmount","type":"uint256"}],"name":"Trade","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"},{"constant":true,"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"allowance_","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"success_","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_derivative","type":"address"}],"name":"assimilator","outputs":[{"internalType":"address","name":"assimilator_","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"balance_","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"chi","outputs":[{"internalType":"contract IFreeFromUpTo","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"derivatives","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_derivative","type":"address"}],"name":"excludeDerivative","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"frozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"liquidity","outputs":[{"internalType":"uint256","name":"total_","type":"uint256"},{"internalType":"uint256[]","name":"individual_","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"numeraires","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_origin","type":"address"},{"internalType":"address","name":"_target","type":"address"},{"internalType":"uint256","name":"_originAmount","type":"uint256"},{"internalType":"uint256","name":"_minTargetAmount","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"originSwap","outputs":[{"internalType":"uint256","name":"targetAmount_","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_origin","type":"address"},{"internalType":"address","name":"_target","type":"address"},{"internalType":"uint256","name":"_originAmount","type":"uint256"},{"internalType":"uint256","name":"_minTargetAmount","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"originSwapDiscountCHI","outputs":[{"internalType":"uint256","name":"targetAmount_","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"partition","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"partitionTickets","outputs":[{"internalType":"bool","name":"initialized","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"partitioned","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"_tokens","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"partitionedWithdraw","outputs":[{"internalType":"uint256[]","name":"withdrawals_","type":"uint256[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_deposit","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"proportionalDeposit","outputs":[{"internalType":"uint256","name":"shellsMinted_","type":"uint256"},{"internalType":"uint256[]","name":"deposits_","type":"uint256[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_shellsToBurn","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"proportionalWithdraw","outputs":[{"internalType":"uint256[]","name":"withdrawals_","type":"uint256[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"reserves","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"_derivatives","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"uint256","name":"_minShells","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"selectiveDeposit","outputs":[{"internalType":"uint256","name":"shellsMinted_","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"_derivatives","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"uint256","name":"_maxShells","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"selectiveWithdraw","outputs":[{"internalType":"uint256","name":"shellsBurned_","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"_toFreezeOrNotToFreeze","type":"bool"}],"name":"setFrozen","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_alpha","type":"uint256"},{"internalType":"uint256","name":"_beta","type":"uint256"},{"internalType":"uint256","name":"_feeAtHalt","type":"uint256"},{"internalType":"uint256","name":"_epsilon","type":"uint256"},{"internalType":"uint256","name":"_lambda","type":"uint256"}],"name":"setParams","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"shell","outputs":[{"internalType":"int128","name":"alpha","type":"int128"},{"internalType":"int128","name":"beta","type":"int128"},{"internalType":"int128","name":"delta","type":"int128"},{"internalType":"int128","name":"epsilon","type":"int128"},{"internalType":"int128","name":"lambda","type":"int128"},{"internalType":"uint256","name":"totalSupply","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes4","name":"_interface","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"supports_","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_origin","type":"address"},{"internalType":"address","name":"_target","type":"address"},{"internalType":"uint256","name":"_maxOriginAmount","type":"uint256"},{"internalType":"uint256","name":"_targetAmount","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"targetSwap","outputs":[{"internalType":"uint256","name":"originAmount_","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"totalSupply_","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"success_","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"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":"success_","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_origin","type":"address"},{"internalType":"address","name":"_target","type":"address"},{"internalType":"uint256","name":"_originAmount","type":"uint256"}],"name":"viewOriginSwap","outputs":[{"internalType":"uint256","name":"targetAmount_","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"viewPartitionClaims","outputs":[{"internalType":"uint256[]","name":"claims_","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"_deposit","type":"uint256"}],"name":"viewProportionalDeposit","outputs":[{"internalType":"uint256","name":"shellsToMint_","type":"uint256"},{"internalType":"uint256[]","name":"depositsToMake_","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"_shellsToBurn","type":"uint256"}],"name":"viewProportionalWithdraw","outputs":[{"internalType":"uint256[]","name":"withdrawalsToHappen_","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address[]","name":"_derivatives","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"viewSelectiveDeposit","outputs":[{"internalType":"uint256","name":"shellsToMint_","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address[]","name":"_derivatives","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"viewSelectiveWithdraw","outputs":[{"internalType":"uint256","name":"shellsToBurn_","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"viewShell","outputs":[{"internalType":"uint256","name":"alpha_","type":"uint256"},{"internalType":"uint256","name":"beta_","type":"uint256"},{"internalType":"uint256","name":"delta_","type":"uint256"},{"internalType":"uint256","name":"epsilon_","type":"uint256"},{"internalType":"uint256","name":"lambda_","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_origin","type":"address"},{"internalType":"address","name":"_target","type":"address"},{"internalType":"uint256","name":"_targetAmount","type":"uint256"}],"name":"viewTargetSwap","outputs":[{"internalType":"uint256","name":"originAmount_","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000003a000000000000000000000000000000000000000000000000000000000000000140000000000000000000000006b175474e89094c44da98b954eedeac495271d0f0000000000000000000000002f4184f73634775cd929c081d6e15ca8f3ff5fab0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f0000000000000000000000002f4184f73634775cd929c081d6e15ca8f3ff5fab0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000ad6e6594e2e9cca9326dd80bffd7baef4e2a10f1000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000ad6e6594e2e9cca9326dd80bffd7baef4e2a10f1000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec700000000000000000000000057813e8d1e77c069e66d0bce3729288ac4d6f0c8000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec700000000000000000000000057813e8d1e77c069e66d0bce3729288ac4d6f0c8000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec700000000000000000000000057ab1ec28d129707052df4df418d58a2d46d5f51000000000000000000000000721e5380627e8ab1a3636edeab05994fc0406bed00000000000000000000000057ab1ec28d129707052df4df418d58a2d46d5f51000000000000000000000000721e5380627e8ab1a3636edeab05994fc0406bed00000000000000000000000057ab1ec28d129707052df4df418d58a2d46d5f5100000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000429d069189e00000000000000000000000000000000000000000000000000000429d069189e00000000000000000000000000000000000000000000000000000429d069189e0000000000000000000000000000000000000000000000000000016345785d8a00000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _assets (address[]): 0x6B175474E89094C44Da98b954EedeAC495271d0F,0x2F4184F73634775CD929C081D6e15ca8f3FF5FaB,0x6B175474E89094C44Da98b954EedeAC495271d0F,0x2F4184F73634775CD929C081D6e15ca8f3FF5FaB,0x6B175474E89094C44Da98b954EedeAC495271d0F,0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48,0xAD6E6594e2E9Cca9326dd80BFFD7BaEf4e2a10F1,0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48,0xAD6E6594e2E9Cca9326dd80BFFD7BaEf4e2a10F1,0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48,0xdAC17F958D2ee523a2206206994597C13D831ec7,0x57813e8D1E77c069e66d0BCE3729288Ac4d6f0c8,0xdAC17F958D2ee523a2206206994597C13D831ec7,0x57813e8D1E77c069e66d0BCE3729288Ac4d6f0c8,0xdAC17F958D2ee523a2206206994597C13D831ec7,0x57Ab1ec28D129707052df4dF418D58a2D46d5f51,0x721e5380627e8aB1a3636eDeAB05994fc0406beD,0x57Ab1ec28D129707052df4dF418D58a2D46d5f51,0x721e5380627e8aB1a3636eDeAB05994fc0406beD,0x57Ab1ec28D129707052df4dF418D58a2D46d5f51
Arg [1] : _assetWeights (uint256[]): 300000000000000000,300000000000000000,300000000000000000,100000000000000000

-----Encoded View---------------
30 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000300
Arg [2] : 00000000000000000000000000000000000000000000000000000000000003a0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000014
Arg [4] : 0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f
Arg [5] : 0000000000000000000000002f4184f73634775cd929c081d6e15ca8f3ff5fab
Arg [6] : 0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f
Arg [7] : 0000000000000000000000002f4184f73634775cd929c081d6e15ca8f3ff5fab
Arg [8] : 0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f
Arg [9] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [10] : 000000000000000000000000ad6e6594e2e9cca9326dd80bffd7baef4e2a10f1
Arg [11] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [12] : 000000000000000000000000ad6e6594e2e9cca9326dd80bffd7baef4e2a10f1
Arg [13] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [14] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7
Arg [15] : 00000000000000000000000057813e8d1e77c069e66d0bce3729288ac4d6f0c8
Arg [16] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7
Arg [17] : 00000000000000000000000057813e8d1e77c069e66d0bce3729288ac4d6f0c8
Arg [18] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7
Arg [19] : 00000000000000000000000057ab1ec28d129707052df4df418d58a2d46d5f51
Arg [20] : 000000000000000000000000721e5380627e8ab1a3636edeab05994fc0406bed
Arg [21] : 00000000000000000000000057ab1ec28d129707052df4df418d58a2d46d5f51
Arg [22] : 000000000000000000000000721e5380627e8ab1a3636edeab05994fc0406bed
Arg [23] : 00000000000000000000000057ab1ec28d129707052df4df418d58a2d46d5f51
Arg [24] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [25] : 0000000000000000000000000000000000000000000000000429d069189e0000
Arg [26] : 0000000000000000000000000000000000000000000000000429d069189e0000
Arg [27] : 0000000000000000000000000000000000000000000000000429d069189e0000
Arg [28] : 000000000000000000000000000000000000000000000000016345785d8a0000
Arg [29] : 0000000000000000000000000000000000000000000000000000000000000000

Libraries Used

Orchestrator : 0xbe1e6ef049b15bc77bb796babecbeea2707770d7
PartitionedLiquidity : 0x2baf1ddd7fdde8ffe15a1911cb032851a8614bf3
ProportionalLiquidity : 0x8dec04e31c6ef645cbb43586f7f0895537d2dfb3
SelectiveLiquidity : 0x2b9b938d934266e185ecd329b145072aab6db5f1
Shells : 0xb13d41506f0fa3a052c01098107510d070e1faa2Unverified
Swaps : 0x5134d1c820fec6e9727d4496d6e102b9f64231f5
ViewLiquidity : 0x08e822f3cc5b0a60a2849588b79088766875d43a

Deployed Bytecode Sourcemap

90617:20745:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;90617:20745:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;105175:367;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;105175:367:0;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;72524:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;71581:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;71581:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;109367:168;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;109367:168:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;95991:460;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;95991:460:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;72484:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;110035:119;;;:::i;:::-;;;;;;;;;;;;;;;;;;;110864:172;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;110864:172:0;;;;;;;;;;;;;;;;;;108736:357;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;108736:357:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;106263:202;;;:::i;:::-;;71672:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;111165:192;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;111165:192:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;102412:269;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;102412:269:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;102412:269:0;;;;;;;;;;;;;;;;;;101633:308;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;101633:308:0;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;101633:308:0;;;;;;;;;;;;;;;;;;99971:379;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;99971:379:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;99971:379:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;99971:379:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;99971:379:0;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;99971:379:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;99971:379:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;99971:379:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;98995:284;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;98995:284:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;103328:381;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;103328:381:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;103328:381:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;103328:381:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;103328:381:0;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;103328:381:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;103328:381:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;103328:381:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;100863:296;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;100863:296:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;100863:296:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;100863:296:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;100863:296:0;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;100863:296:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;100863:296:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;100863:296:0;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;109742:164;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;109742:164:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;98147:460;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;98147:460:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;104872:295;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;104872:295:0;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;104872:295:0;;;;;;;;;;;;;;;;;95117:173;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;95117:173:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;107588:239;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;107588:239:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;107588:239:0;;;;;;;;;;;;;;;;;72450:25;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;72450:25:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;97338:284;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;97338:284:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;71552:20;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;104128:298;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;104128:298:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;104128:298:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;104128:298:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;104128:298:0;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;104128:298:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;104128:298:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;104128:298:0;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;71627:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;71627:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;106950:305;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;106950:305:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;106950:305:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;106950:305:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;106950:305:0;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;106950:305:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;106950:305:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;106950:305:0;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;106950:305:0;;;;;;;;;;;;;;;;;96459:483;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;96459:483:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;72416:27;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;72416:27:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;108062:317;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;108062:317:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;72222:60;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;72222:60:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;105997:258;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;105997:258:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;105997:258:0;;;;;;;;;;;;;;;;;72381:28;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;72381:28:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;94068:460;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;94068:460:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;91564:93;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;93673:261;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;93673:261:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;110426:203;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;110426:203:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;71718:18;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95298:161;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;95298:161:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;94886:223;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;105175:367;105269:14;105352:10;105317:45;;;:31;;;:45;;;;:105;;;;105412:10;105390:32;;;105397:10;105390:18;;:32;;;;105317:105;:182;;;;105489:10;105467:32;;;105474:10;105467:18;;:32;;;;105317:182;105305:194;;105175:367;;;:::o;72524:26::-;;;;;;;;;;;;;:::o;71581:39::-;;;;;;;;;;;;;;;;;;;:::o;109367:168::-;109446:13;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;109485:6;:14;109500:5;109507:8;109517:7;109485:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;109485:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;109485:40:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;109485:40:0;;;;;;;;;;;;;;;;109474:51;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;109367:168;;;;:::o;95991:460::-;96231:18;96175:9;92631;92613:15;:27;92605:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;96286:5;:16;96303:5;96310:7;96319;96328:13;96343:10;96286:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;96286:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;96286:68:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;96286:68:0;;;;;;;;;;;;;;;;96270:84;;96391:16;96375:13;:32;96367:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;95991:460;;;;;;;;:::o;72484:31::-;;;;;;;;;;;;;:::o;110035:119::-;110080:17;110127:5;:17;;;110112:32;;110035:119;:::o;110864:172::-;110917:11;110939:25;110992:13;:27;111020:5;110992:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;110992:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;110992:34:0;;;;;;39:16:-1;36:1;17:17;2:54;110992:34:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;110992:34:0;;;;;;;;;;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;385:12;380:3;373:25;421:4;416:3;412:14;405:21;;0:433;;110992:34:0;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;110992:34:0;;;;;;;;;;;110985:41;;;;110864:172;;:::o;108736:357::-;108883:13;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;108926:16;:25;108943:7;108926:25;;;;;;;;;;;;;;;:37;;;;;;;;;;;;108925:38;108917:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;109027:6;:19;109047:5;109054:7;109063:10;109075:7;109027:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;109027:56:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;109027:56:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;109027:56:0;;;;;;;;;;;;;;;;109016:67;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;108736:357;;;;;:::o;106263:202::-;91958:5;;;;;;;;;;;91944:19;;:10;:19;;;91936:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;106325:6;;;;;;;;;;;106317:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;106369:20;:30;106400:5;106407:16;106369:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;106369:55:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;106369:55:0;;;;106451:4;106437:11;;:18;;;;;;;;;;;;;;;;;;106263:202::o;71672:37::-;71707:2;71672:37;:::o;111165:192::-;111255:20;111311:5;:18;;:31;111330:11;111311:31;;;;;;;;;;;;;;;:36;;;;;;;;;;;;111296:51;;111165:192;;;:::o;102412:269::-;102523:18;102552:29;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;102609:21;:45;102655:5;102662:8;102609:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;102609:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;102609:62:0;;;;;;39:16:-1;36:1;17:17;2:54;102609:62:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;102609:62:0;;;;;;;;;;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;385:12;380:3;373:25;421:4;416:3;412:14;405:21;;0:433;;102609:62:0;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;102609:62:0;;;;;;;;;;;102602:69;;;;102412:269;;;:::o;101633:308::-;101793:18;101822:23;101737:9;92631;92613:15;:27;92605:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;101873:21;:41;101915:5;101922:8;101873:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;101873:58:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;101873:58:0;;;;;;39:16:-1;36:1;17:17;2:54;101873:58:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;101873:58:0;;;;;;;;;;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;385:12;380:3;373:25;421:4;416:3;412:14;405:21;;0:433;;101873:58:0;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;101873:58:0;;;;;;;;;;;101866:65;;;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;101633:308;;;;;;:::o;99971:379::-;100207:18;100151:9;92631;92613:15;:27;92605:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;100262;:35;100298:5;100305:12;;100319:8;;100329:10;100262:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;100262:78:0;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;100262:78:0;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;100262:78:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;100262:78:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;100262:78:0;;;;;;;;;;;;;;;;100246:94;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;99971:379;;;;;;;;;:::o;98995:284::-;99154:18;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;99209:5;:20;99230:5;99237:7;99246;99255:13;99209:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;99209:60:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;99209:60:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;99209:60:0;;;;;;;;;;;;;;;;99193:76;;98995:284;;;;;:::o;103328:381::-;103565:18;103509:9;92631;92613:15;:27;92605:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;103620;:36;103657:5;103664:12;;103678:8;;103688:10;103620:79;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;103620:79:0;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;103620:79:0;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;103620:79:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;103620:79:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;103620:79:0;;;;;;;;;;;;;;;;103604:95;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;103328:381;;;;;;;;;:::o;100863:296::-;101024:18;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;101079:18;:39;101119:5;101126:12;;101140:8;;101079:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;101079:70:0;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;101079:70:0;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;101079:70:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;101079:70:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;101079:70:0;;;;;;;;;;;;;;;;101063:86;;100863:296;;;;;;:::o;109742:164::-;109827:13;109872:5;:14;;:24;109887:8;109872:24;;;;;;;;;;;;;;;;109861:35;;109742:164;;;:::o;98147:460::-;98387:18;98331:9;92631;92613:15;:27;92605:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;98442:5;:16;98459:5;98466:7;98475;98484:13;98499:10;98442:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;98442:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;98442:68:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;98442:68:0;;;;;;;;;;;;;;;;98426:84;;98547:16;98531:13;:32;98523:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;98147:460;;;;;;;;:::o;104872:295::-;105039:26;104982:9;92631;92613:15;:27;92605:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92370:11;;;;;;;;;;;92369:12;92361:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;105093:21;:42;105136:5;105143:13;105093:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;105093:64:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;105093:64:0;;;;;;39:16:-1;36:1;17:17;2:54;105093:64:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;105093:64:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;385:12;380:3;373:25;421:4;416:3;412:14;405:21;;0:433;;105093:64:0;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;105093:64:0;;;;;;;;;;;105086:71;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;104872:295;;;;;:::o;95117:173::-;91958:5;;;;;;;;;;;91944:19;;:10;:19;;;91936:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95203:33;95213:22;95203:33;;;;;;;;;;;;;;;;;;;;;;95258:22;95249:6;;:31;;;;;;;;;;;;;;;;;;95117:173;:::o;107588:239::-;107696:21;92485:11;;;;;;;;;;;92477:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;107745:20;:40;107786:5;107793:16;107811:5;107745:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;107745:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;107745:72:0;;;;;;39:16:-1;36:1;17:17;2:54;107745:72:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;107745:72:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;385:12;380:3;373:25;421:4;416:3;412:14;405:21;;0:433;;107745:72:0;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;107745:72:0;;;;;;;;;;;107738:79;;107588:239;;;:::o;72450:25::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;97338:284::-;97497:18;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;97552:5;:20;97573:5;97580:7;97589;97598:13;97552:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;97552:60:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;97552:60:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;97552:60:0;;;;;;;;;;;;;;;;97536:76;;97338:284;;;;;:::o;71552:20::-;;;;;;;;;;;;;:::o;104128:298::-;104290:18;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;104345:18;:40;104386:5;104393:12;;104407:8;;104345:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;104345:71:0;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;104345:71:0;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;104345:71:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;104345:71:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;104345:71:0;;;;;;;;;;;;;;;;104329:87;;104128:298;;;;;;:::o;71627:38::-;;;;;;;;;;;;;;;;;;;:::o;106950:305::-;107104:29;92485:11;;;;;;;;;;;92477:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;107161:20;:40;107202:5;107209:16;107227:7;;107236:8;;107161:84;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;107161:84:0;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;107161:84:0;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;107161:84:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;107161:84:0;;;;;;39:16:-1;36:1;17:17;2:54;107161:84:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;107161:84:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;385:12;380:3;373:25;421:4;416:3;412:14;405:21;;0:433;;107161:84:0;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;107161:84:0;;;;;;;;;;;107154:91;;106950:305;;;;;;:::o;96459:483::-;96722:18;96654:9;92631;92613:15;:27;92605:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92233:6;;;;;;;;;;;92232:7;92224:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;91698:16;91717:9;91698:28;;96777:5;:16;96794:5;96801:7;96810;96819:13;96834:10;96777:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;96777:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;96777:68:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;96777:68:0;;;;;;;;;;;;;;;;96761:84;;96882:16;96866:13;:32;96858:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91749:16;91804:8;;:15;;91799:2;:20;91787:9;91776:8;91768:5;:16;:28;:51;91749:70;;91614:42;91830:16;;;91847:10;91880:5;91871;91860:8;:16;91859:26;;;;;;91830:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;91830:56:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;91830:56:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;91830:56:0;;;;;;;;;;;;;;;;;92139:1;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;96459:483;;;;;;;;:::o;72416:27::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;108062:317::-;108179:13;92068:10;;;;;;;;;;;92060:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92123:5;92110:10;;:18;;;;;;;;;;;;;;;;;;108222:16;:28;108239:10;108222:28;;;;;;;;;;;;;;;:40;;;;;;;;;;;;108221:41;108213:89;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;108326:6;:15;108342:5;108349:10;108361:7;108326:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;108326:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;108326:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;108326:43:0;;;;;;;;;;;;;;;;108315:54;;92164:4;92151:10;;:17;;;;;;;;;;;;;;;;;;108062:317;;;;:::o;72222:60::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;105997:258::-;106115:34;92370:11;;;;;;;;;;;92369:12;92361:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;106177:21;:46;106224:5;106231:13;106177:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;106177:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;106177:68:0;;;;;;39:16:-1;36:1;17:17;2:54;106177:68:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;106177:68:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;385:12;380:3;373:25;421:4;416:3;412:14;405:21;;0:433;;106177:68:0;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;106177:68:0;;;;;;;;;;;106170:75;;105997:258;;;:::o;72381:28::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;94068:460::-;91958:5;;;;;;;;;;;91944:19;;:10;:19;;;91936:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94165:12;94180:10;:17;;;;94165:32;;94216:6;94225:1;94216:10;;94211:257;94232:10;:17;;;;94228:1;:21;94211:257;;;94304:10;94315:1;94304:13;;;;;;;;;;;;;;;;;;;;;;;;;94289:28;;:11;:28;;;94285:73;;;94319:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94285:73;94392:8;94401:1;94392:11;;;;;;;;;;;;;;;;;;;;;;;;;94377:26;;:11;:26;;;94373:69;;;94405:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94373:69;94251:3;;;;;;;94211:257;;;;94487:5;:18;;:31;94506:11;94487:31;;;;;;;;;;;;;;;;94480:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92004:1;94068:460;:::o;91564:93::-;91614:42;91564:93;:::o;93673:261::-;91958:5;;;;;;;;;;;91944:19;;:10;:19;;;91936:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93849:12;:22;93872:5;93879:6;93887:5;93894:10;93906:8;93916:7;93849:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;93849:75:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;93849:75:0;;;;93673:261;;;;;:::o;110426:203::-;110536:15;110585:5;:16;;:24;110602:6;110585:24;;;;;;;;;;;;;;;:34;110610:8;110585:34;;;;;;;;;;;;;;;;110572:47;;110426:203;;;;:::o;71718:18::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;95298:161::-;91958:5;;;;;;;;;;;91944:19;;:10;:19;;;91936:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95409:9;95382:37;;95402:5;;;;;;;;;;;95382:37;;;;;;;;;;;;95440:9;95432:5;;:17;;;;;;;;;;;;;;;;;;95298:161;:::o;94886:223::-;94941:11;94963:10;94984:11;95006:13;95030:12;95070;:22;95093:5;95070:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;95070:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;95070:29:0;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;95070:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95063:36;;;;;;;;;;94886:223;;;;;:::o

Swarm Source

bzzr://c6b0a2499be67182f0391deae1a790e9430bd1543eb3d9f9876a50b5330ae1be

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services