Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• library ABDKMath64x64
•    - function fromInt (int256 x)
•    - function toInt (int128 x)
•    - function fromUInt (uint256 x)
•    - function toUInt (int128 x)
•    - function from128x128 (int256 x)
•    - function to128x128 (int128 x)
•    - function add (int128 x, int128 y)
•    - function sub (int128 x, int128 y)
•    - function mul (int128 x, int128 y)
•    - function muli (int128 x, int256 y)
•    - function mulu (int128 x, uint256 y)
•    - function div (int128 x, int128 y)
•    - function divi (int256 x, int256 y)
•    - function divu (uint256 x, uint256 y)
•    - function neg (int128 x)
•    - function abs (int128 x)
•    - function inv (int128 x)
•    - function avg (int128 x, int128 y)
•    - function gavg (int128 x, int128 y)
•    - function pow (int128 x, uint256 y)
•    - function sqrt (int128 x)
•    - function log_2 (int128 x)
•    - function ln (int128 x)
•    - function exp_2 (int128 x)
•    - function exp (int128 x)
•    - function divuu (uint256 x, uint256 y)
•    - function sqrtu (uint256 x)
•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function setApprovalForAll(address op ...
•    - function getApproved(uint256 tokenId)
•    - function isApprovedForAll(address own ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• interface IBattledog
•    - function balanceOf(address _caller)
•    - function getPlayerOwners(address _use ...
•    - function ownerOf(uint256 _index)
•    - function blacklisted(uint256 _index)
•  contract ProofOfPlay is Ownable, R ... *
•    - function getMinerData()
•    - function getActiveMiner(uint256 index ...
•    - function getOwnerData(uint256 _tokenI ...
•    - function mineGAME(uint256[] calldata ...
•    - function getCollectors(uint256 _token ...
•    - function setCollectors (string memory ...
•    - function setTimeLock(uint256 _seconds ...
•    - function setMultiplier (uint256 _mult ...
•    - function setTime(uint256 _time)
•    - function setBonuses (uint256 _activat ...
•    - function setGuard (address _newGuard)
•    - function setBattledog (address _battl ...
•    - function setGametoken (address _gamet ...
•    - function withdrawERC20(IERC20 _paytok ...
•    - function pause()
•    - function unpause()

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at SonicScan.org on 2025-01-02
*/

// SPDX-License-Identifier: MIT

// File: abdk-libraries-solidity/ABDKMath64x64.sol


/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <[email protected]>
 */
pragma solidity ^0.8.0;

/**
 * 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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      require (x <= 0x7FFFFFFFFFFFFFFF);
      return int128 (int256 (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) {
    unchecked {
      require (x >= 0);
      return uint64 (uint128 (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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      if (y == 0) return 0;

      require (x >= 0);

      uint256 lo = (uint256 (int256 (x)) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
      uint256 hi = uint256 (int256 (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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      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) {
    unchecked {
      int256 m = int256 (x) * int256 (y);
      require (m >= 0);
      require (m <
          0x4000000000000000000000000000000000000000000000000000000000000000);
      return int128 (sqrtu (uint256 (m)));
    }
  }

  /**
   * 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) {
    unchecked {
      bool negative = x < 0 && y & 1 == 1;

      uint256 absX = uint128 (x < 0 ? -x : x);
      uint256 absResult;
      absResult = 0x100000000000000000000000000000000;

      if (absX <= 0x10000000000000000) {
        absX <<= 63;
        while (y != 0) {
          if (y & 0x1 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x2 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x4 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x8 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          y >>= 4;
        }

        absResult >>= 64;
      } else {
        uint256 absXShift = 63;
        if (absX < 0x1000000000000000000000000) { absX <<= 32; absXShift -= 32; }
        if (absX < 0x10000000000000000000000000000) { absX <<= 16; absXShift -= 16; }
        if (absX < 0x1000000000000000000000000000000) { absX <<= 8; absXShift -= 8; }
        if (absX < 0x10000000000000000000000000000000) { absX <<= 4; absXShift -= 4; }
        if (absX < 0x40000000000000000000000000000000) { absX <<= 2; absXShift -= 2; }
        if (absX < 0x80000000000000000000000000000000) { absX <<= 1; absXShift -= 1; }

        uint256 resultShift = 0;
        while (y != 0) {
          require (absXShift < 64);

          if (y & 0x1 != 0) {
            absResult = absResult * absX >> 127;
            resultShift += absXShift;
            if (absResult > 0x100000000000000000000000000000000) {
              absResult >>= 1;
              resultShift += 1;
            }
          }
          absX = absX * absX >> 127;
          absXShift <<= 1;
          if (absX >= 0x100000000000000000000000000000000) {
              absX >>= 1;
              absXShift += 1;
          }

          y >>= 1;
        }

        require (resultShift < 64);
        absResult >>= 64 - resultShift;
      }
      int256 result = negative ? -int256 (absResult) : int256 (absResult);
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * 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) {
    unchecked {
      require (x >= 0);
      return int128 (sqrtu (uint256 (int256 (x)) << 64));
    }
  }

  /**
   * 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) {
    unchecked {
      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 (int256 (x)) << uint256 (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) {
    unchecked {
      require (x > 0);

      return int128 (int256 (
          uint256 (int256 (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) {
    unchecked {
      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 >>= uint256 (int256 (63 - (x >> 64)));
      require (result <= uint256 (int256 (MAX_64x64)));

      return int128 (int256 (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) {
    unchecked {
      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) {
    unchecked {
      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

        result += xh == hi >> 128 ? xl / y : 1;
      }

      require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return uint128 (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) private pure returns (uint128) {
    unchecked {
      if (x == 0) return 0;
      else {
        uint256 xx = x;
        uint256 r = 1;
        if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; }
        if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; }
        if (xx >= 0x100000000) { xx >>= 32; r <<= 16; }
        if (xx >= 0x10000) { xx >>= 16; r <<= 8; }
        if (xx >= 0x100) { xx >>= 8; r <<= 4; }
        if (xx >= 0x10) { xx >>= 4; r <<= 2; }
        if (xx >= 0x4) { r <<= 1; }
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1; // Seven iterations should be enough
        uint256 r1 = x / r;
        return uint128 (r < r1 ? r : r1);
      }
    }
  }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// File: contracts/Proof of Play.sol

pragma solidity ^0.8.17;

interface IBattledog {
    struct Player {
        string name;
        uint256 id;
        uint256 level;
        uint256 attack;
        uint256 defence;
        uint256 fights;
        uint256 wins;
        uint256 payout;
        uint256 activate;
        uint256 history;
    }

    function balanceOf(address _caller) external view returns (uint256);
    function getPlayerOwners(address _user) external returns (Player[] memory);
    function ownerOf(uint256 _index) external view returns (address);
    function blacklisted(uint256 _index) external view returns (bool);
}

/**
 * @title Proof of Play Miner contract
 */
contract ProofOfPlay is Ownable, ReentrancyGuard {
    IERC20 public GAMEToken;
    uint256 public totalClaimedRewards;
    uint256 public multiplier = 10;
    uint256 public timeLock = 604800;
    uint256 private divisor = 1 ether;
    address private guard; 
    address public battledogs;
    bool public paused = false; 
    uint256 public activatebonus = 5;
    uint256 public levelbonus = 4;
    uint256 public winsbonus = 3;
    uint256 public fightsbonus = 2;
    uint256 public historybonus = 1;
    uint256 private startTime;
        

    // Declare the ActiveMiners & Blacklist arrays
    uint256 public activeMinersLength;

    mapping(uint256 => IBattledog.Player) public ActiveMiners;
    mapping(uint256 => Miner) public Collectors;
    mapping(uint256 => uint256) public MinerClaims;
    mapping(uint256 => bool) private minerstate;

    struct Miner {
        string name;
        uint256 id;
        uint256 level;
        uint256 attack;
        uint256 defence;
        uint256 fights;
        uint256 wins;
        uint256 payout;
        uint256 activate;
        uint256 history;
    }

    event RewardClaimedByMiner (address indexed user, uint256 amount);
    
    constructor(
        address _GAMEToken,
        address _battledogs,
        address _newGuard
    ) {
        GAMEToken = IERC20(_GAMEToken);
        battledogs = _battledogs;
        guard = _newGuard;
        startTime = block.timestamp;
    }

    using ABDKMath64x64 for uint256;  

    modifier onlyGuard() {
        require(msg.sender == guard, "Not authorized.");
        _;
    }

    function getMinerData() public nonReentrant {
    uint256 total = IBattledog(battledogs).balanceOf(msg.sender);
    IBattledog.Player[] memory players = IBattledog(battledogs).getPlayerOwners(msg.sender);
    
      for (uint256 i = 0; i < total; i++) {
        uint256 tokenId = players[i].id;

        // Create a new instance of the Miner struct with the player's data
        ActiveMiners[tokenId] = players[i];
        
        // Increment the activeMinersLength
        if (!minerstate[tokenId]) {
          activeMinersLength++;
        }

        minerstate[tokenId] = true;
      }
    }

    function getActiveMiner(uint256 index) public view returns (IBattledog.Player memory) {
        require(index < activeMinersLength, "Index out of range.");
        return ActiveMiners[index];
    }

    function getOwnerData(uint256 _tokenId) internal view returns (bool) {        
    // Get the token id owned by the msg.sender
      address owner = IBattledog(battledogs).ownerOf(_tokenId);
        // compare the _tokenId 
        if (owner == msg.sender) {
                return true;
              }        
          return false;
    }

    function mineGAME(uint256[] calldata _nfts) public nonReentrant {
    // Require Contract isn't paused
    require(!paused, "Paused Contract");
    // Populate the ActiveMiners array
    uint256 total = IBattledog(battledogs).balanceOf(msg.sender);
    IBattledog.Player[] memory players = IBattledog(battledogs).getPlayerOwners(msg.sender);
    
    for (uint256 i = 0; i < total; i++) {
        uint256 tokenId = players[i].id;
        // Create a new instance of the Miner struct with the player's data
        ActiveMiners[tokenId] = players[i];
        
        // Increment the activeMinersLength
        if (!minerstate[tokenId]) {
          activeMinersLength++;
          minerstate[tokenId] = true;
        }

    }

        for (uint256 a = 0; a < _nfts.length; a++) {
            uint256 tokenId = _nfts[a]; // // Current NFT id
            // Require Token Ownership    
            require(getOwnerData(tokenId), "Not Owner");        
            // Require Miner hasn't claimed within timelock  
              uint256 unlock = MinerClaims[tokenId] + timeLock;  
              uint256 currentTime = block.timestamp;
            require(unlock < currentTime, "Timelocked");
            // Require Miner is not on blacklist
            require(!IBattledog(battledogs).blacklisted(tokenId), "NFT Blacklisted");

            // Check if the miner is activated
            if (ActiveMiners[tokenId].activate > 0) {
            uint256 freq; uint256 activatefactor; uint256 activate; uint256 level; 
            uint256 fights; uint256 wins; uint256 history; uint256 rewards;

              // Calculate Rewards
              if (MinerClaims[tokenId] > 0) {                
              freq = (currentTime - MinerClaims[tokenId]) / timeLock;
              } else if (((currentTime - startTime) / timeLock) < 0) {
                freq = 1;
              } else {
                freq = ((currentTime - startTime) / timeLock);
              }

              activatefactor = (ActiveMiners[tokenId].activate - 1) * activatebonus;
              activate = ((ActiveMiners[tokenId].activate - 1)) * multiplier * freq;
              level = ((ActiveMiners[tokenId].level - Collectors[tokenId].level) * levelbonus) + activatefactor;
              
              if (ActiveMiners[tokenId].fights > Collectors[tokenId].fights) {  
              fights = ((ActiveMiners[tokenId].fights - Collectors[tokenId].fights) * fightsbonus) + activatefactor;
              }

              if (ActiveMiners[tokenId].wins > Collectors[tokenId].wins) {
              wins = ((ActiveMiners[tokenId].wins - Collectors[tokenId].wins) * winsbonus) + activatefactor;
              }

              history = ((ActiveMiners[tokenId].history - Collectors[tokenId].history) * historybonus) + activatefactor;
              rewards = (activate + level + fights + wins + history) * divisor;

                // Check the contract for adequate withdrawal balance
                require(GAMEToken.balanceOf(address(this)) > rewards, "Not Enough Reserves");      
                // Transfer the rewards amount to the miner
                require(GAMEToken.transfer(msg.sender, rewards), "Failed Transfer");
                // Register claim
                getCollectors(tokenId);
                // Register claim timestamp
                MinerClaims[tokenId] = currentTime; // Record the miner's claim timestamp
                // TotalClaimedRewards
                totalClaimedRewards += rewards;       
                // Emit event
                emit RewardClaimedByMiner(msg.sender, rewards);
            } else {
                require(ActiveMiners[tokenId].activate > 0, "ActivateUp Required");
            }
        }
    }

    function getCollectors(uint256 _tokenId) internal {
        // Read the miner data from the ActiveMiners mapping
        IBattledog.Player memory activeMiner = ActiveMiners[_tokenId];

        // Transfer the miner data to the Collectors mapping
        Collectors[_tokenId] = Miner(
            activeMiner.name,
            activeMiner.id,
            activeMiner.level,
            activeMiner.attack,
            activeMiner.defence,
            activeMiner.fights,
            activeMiner.wins,
            activeMiner.payout,
            activeMiner.activate,
            activeMiner.history
        );
    }
    
    function setCollectors (string memory _name, uint256 _id, uint256 _level, 
    uint256 _attack, uint256 _defence, uint256 _fights, uint256 _wins, 
    uint256 _payout, uint256 _activate, uint256 _history, uint256 _time) external onlyOwner nonReentrant {
       Collectors[_id] = Miner(
        _name,
        _id,
        _level,
        _attack,
        _defence,
        _fights,
        _wins,
        _payout,
        _activate,
        _history
        );  
        
      MinerClaims[_id] = _time; // Record the miner's claim timestamp
    }

    function setTimeLock(uint256 _seconds) external onlyOwner {
        timeLock = _seconds;
    }

    function setMultiplier (uint256 _multiples) external onlyOwner() {
        multiplier = _multiples;
    }

    function setTime(uint256 _time) external onlyOwner {
      startTime = _time;
    }

    function setBonuses (uint256 _activate, uint256 _level, uint256 _wins, uint256 _fights, uint256 _history) external onlyOwner() {
        activatebonus = _activate;
        levelbonus = _level;
        winsbonus = _wins;
        fightsbonus = _fights;
        historybonus = _history;
    }

    function setGuard (address _newGuard) external onlyGuard {
        guard = _newGuard;
    }

    function setBattledog (address _battledog) external onlyGuard {
        battledogs = _battledog;
    }

    function setGametoken (address _gametoken) external onlyGuard {
        GAMEToken = IERC20(_gametoken);
    }

    function withdrawERC20(IERC20 _paytoken, uint256 _amount) external payable onlyOwner {
        IERC20 paytoken = _paytoken;
        paytoken.transfer(msg.sender, _amount);
    }

    event Pause();
    function pause() public onlyGuard {
        require(!paused, "Contract already paused.");
        paused = true;
        emit Pause();
    }

    event Unpause();
    function unpause() public onlyGuard {
        require(paused, "Contract not paused.");
        paused = false;
        emit Unpause();
    } 
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_GAMEToken","type":"address"},{"internalType":"address","name":"_battledogs","type":"address"},{"internalType":"address","name":"_newGuard","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[],"name":"Pause","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardClaimedByMiner","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpause","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"ActiveMiners","outputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"level","type":"uint256"},{"internalType":"uint256","name":"attack","type":"uint256"},{"internalType":"uint256","name":"defence","type":"uint256"},{"internalType":"uint256","name":"fights","type":"uint256"},{"internalType":"uint256","name":"wins","type":"uint256"},{"internalType":"uint256","name":"payout","type":"uint256"},{"internalType":"uint256","name":"activate","type":"uint256"},{"internalType":"uint256","name":"history","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"Collectors","outputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"level","type":"uint256"},{"internalType":"uint256","name":"attack","type":"uint256"},{"internalType":"uint256","name":"defence","type":"uint256"},{"internalType":"uint256","name":"fights","type":"uint256"},{"internalType":"uint256","name":"wins","type":"uint256"},{"internalType":"uint256","name":"payout","type":"uint256"},{"internalType":"uint256","name":"activate","type":"uint256"},{"internalType":"uint256","name":"history","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GAMEToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MinerClaims","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activatebonus","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activeMinersLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"battledogs","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fightsbonus","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getActiveMiner","outputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"level","type":"uint256"},{"internalType":"uint256","name":"attack","type":"uint256"},{"internalType":"uint256","name":"defence","type":"uint256"},{"internalType":"uint256","name":"fights","type":"uint256"},{"internalType":"uint256","name":"wins","type":"uint256"},{"internalType":"uint256","name":"payout","type":"uint256"},{"internalType":"uint256","name":"activate","type":"uint256"},{"internalType":"uint256","name":"history","type":"uint256"}],"internalType":"struct IBattledog.Player","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinerData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"historybonus","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"levelbonus","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_nfts","type":"uint256[]"}],"name":"mineGAME","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"multiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_battledog","type":"address"}],"name":"setBattledog","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_activate","type":"uint256"},{"internalType":"uint256","name":"_level","type":"uint256"},{"internalType":"uint256","name":"_wins","type":"uint256"},{"internalType":"uint256","name":"_fights","type":"uint256"},{"internalType":"uint256","name":"_history","type":"uint256"}],"name":"setBonuses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_level","type":"uint256"},{"internalType":"uint256","name":"_attack","type":"uint256"},{"internalType":"uint256","name":"_defence","type":"uint256"},{"internalType":"uint256","name":"_fights","type":"uint256"},{"internalType":"uint256","name":"_wins","type":"uint256"},{"internalType":"uint256","name":"_payout","type":"uint256"},{"internalType":"uint256","name":"_activate","type":"uint256"},{"internalType":"uint256","name":"_history","type":"uint256"},{"internalType":"uint256","name":"_time","type":"uint256"}],"name":"setCollectors","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_gametoken","type":"address"}],"name":"setGametoken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newGuard","type":"address"}],"name":"setGuard","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_multiples","type":"uint256"}],"name":"setMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_time","type":"uint256"}],"name":"setTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_seconds","type":"uint256"}],"name":"setTimeLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"timeLock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalClaimedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"winsbonus","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_paytoken","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawERC20","outputs":[],"stateMutability":"payable","type":"function"}]

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

000000000000000000000000ab803c683000c3ab8836477b0e2bdc45c20139d100000000000000000000000096f2b371d800bf32bb89dad05b61b380030030a5000000000000000000000000c0ba543b1f4a340aca0157c1988f3e216c9e1774

-----Decoded View---------------
Arg [0] : _GAMEToken (address): 0xaB803C683000C3Ab8836477B0e2BDC45C20139d1
Arg [1] : _battledogs (address): 0x96F2B371D800bf32BB89DAd05b61B380030030A5
Arg [2] : _newGuard (address): 0xc0ba543B1F4A340acA0157C1988F3E216C9e1774

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000ab803c683000c3ab8836477b0e2bdc45c20139d1
Arg [1] : 00000000000000000000000096f2b371d800bf32bb89dad05b61b380030030a5
Arg [2] : 000000000000000000000000c0ba543b1f4a340aca0157c1988f3e216c9e1774

42638:9320:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42976:32;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;42976:32:0;;;;;;;;42765:30;;;;;;;;;;;;;;;;51309:111;;;;;;;;;;-1:-1:-1;51309:111:0;;;;;:::i;:::-;;:::i;:::-;;44904:200;;;;;;;;;;-1:-1:-1;44904:200:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;43299:57::-;;;;;;;;;;-1:-1:-1;43299:57:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;:::i;50700:85::-;;;;;;;;;;-1:-1:-1;50700:85:0;;;;;:::i;:::-;;:::i;51810:144::-;;;;;;;;;;;;;:::i;51197:104::-;;;;;;;;;;-1:-1:-1;51197:104:0;;;;;:::i;:::-;;:::i;42910:25::-;;;;;;;;;;-1:-1:-1;42910:25:0;;;;-1:-1:-1;;;;;42910:25:0;;;;;;-1:-1:-1;;;;;3376:32:1;;;3358:51;;3346:2;3331:18;42910:25:0;3212:203:1;43413:46:0;;;;;;;;;;-1:-1:-1;43413:46:0;;;;;:::i;:::-;;;;;;;;;;;;;;50481:96;;;;;;;;;;-1:-1:-1;50481:96:0;;;;;:::i;:::-;;:::i;42942:26::-;;;;;;;;;;-1:-1:-1;42942:26:0;;;;-1:-1:-1;;;42942:26:0;;;;;;;;;3585:14:1;;3578:22;3560:41;;3548:2;3533:18;42942:26:0;3420:187:1;44282:614:0;;;;;;;;;;;;;:::i;50585:107::-;;;;;;;;;;-1:-1:-1;50585:107:0;;;;;:::i;:::-;;:::i;32348:103::-;;;;;;;;;;;;;:::i;43257:33::-;;;;;;;;;;;;;;;;51636:144;;;;;;;;;;;;;:::i;43015:29::-;;;;;;;;;;;;;;;;31707:87;;;;;;;;;;-1:-1:-1;31753:7:0;31780:6;-1:-1:-1;;;;;31780:6:0;31707:87;;43051:28;;;;;;;;;;;;;;;;51428:180;;;;;;:::i;:::-;;:::i;43123:31::-;;;;;;;;;;;;;;;;42694:23;;;;;;;;;;-1:-1:-1;42694:23:0;;;;-1:-1:-1;;;;;42694:23:0;;;49909:564;;;;;;;;;;-1:-1:-1;49909:564:0;;;;;:::i;:::-;;:::i;42802:32::-;;;;;;;;;;;;;;;;42724:34;;;;;;;;;;;;;;;;51096:93;;;;;;;;;;-1:-1:-1;51096:93:0;;;;;:::i;:::-;;:::i;43363:43::-;;;;;;;;;;-1:-1:-1;43363:43:0;;;;;:::i;:::-;;:::i;45469:3789::-;;;;;;;;;;-1:-1:-1;45469:3789:0;;;;;:::i;:::-;;:::i;32606:201::-;;;;;;;;;;-1:-1:-1;32606:201:0;;;;;:::i;:::-;;:::i;50793:295::-;;;;;;;;;;-1:-1:-1;50793:295:0;;;;;:::i;:::-;;:::i;43086:30::-;;;;;;;;;;;;;;;;51309:111;44229:5;;-1:-1:-1;;;;;44229:5:0;44215:10;:19;44207:47;;;;-1:-1:-1;;;44207:47:0;;;;;;;:::i;:::-;;;;;;;;;51382:9:::1;:30:::0;;-1:-1:-1;;;;;;51382:30:0::1;-1:-1:-1::0;;;;;51382:30:0;;;::::1;::::0;;;::::1;::::0;;51309:111::o;44904:200::-;44964:24;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44964:24:0;45017:18;;45009:5;:26;45001:58;;;;-1:-1:-1;;;45001:58:0;;8037:2:1;45001:58:0;;;8019:21:1;8076:2;8056:18;;;8049:30;-1:-1:-1;;;8095:18:1;;;8088:49;8154:18;;45001:58:0;7835:343:1;45001:58:0;45077:19;;;;:12;:19;;;;;;;45070:26;;;;;;;;;;;;45077:19;;45070:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44904:200;;;:::o;43299:57::-;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50700:85::-;31593:13;:11;:13::i;:::-;50760:9:::1;:17:::0;50700:85::o;51810:144::-;44229:5;;-1:-1:-1;;;;;44229:5:0;44215:10;:19;44207:47;;;;-1:-1:-1;;;44207:47:0;;;;;;;:::i;:::-;51865:6:::1;::::0;-1:-1:-1;;;51865:6:0;::::1;;;51857:39;;;::::0;-1:-1:-1;;;51857:39:0;;8770:2:1;51857:39:0::1;::::0;::::1;8752:21:1::0;8809:2;8789:18;;;8782:30;-1:-1:-1;;;8828:18:1;;;8821:50;8888:18;;51857:39:0::1;8568:344:1::0;51857:39:0::1;51907:6;:14:::0;;-1:-1:-1;;;;51907:14:0::1;::::0;;51937:9:::1;::::0;::::1;::::0;51916:5:::1;::::0;51937:9:::1;51810:144::o:0;51197:104::-;44229:5;;-1:-1:-1;;;;;44229:5:0;44215:10;:19;44207:47;;;;-1:-1:-1;;;44207:47:0;;;;;;;:::i;:::-;51270:10:::1;:23:::0;;-1:-1:-1;;;;;;51270:23:0::1;-1:-1:-1::0;;;;;51270:23:0;;;::::1;::::0;;;::::1;::::0;;51197:104::o;50481:96::-;31593:13;:11;:13::i;:::-;50550:8:::1;:19:::0;50481:96::o;44282:614::-;28684:21;:19;:21::i;:::-;44360:10:::1;::::0;44349:44:::1;::::0;-1:-1:-1;;;44349:44:0;;44382:10:::1;44349:44;::::0;::::1;3358:51:1::0;44333:13:0::1;::::0;-1:-1:-1;;;;;44360:10:0::1;::::0;44349:32:::1;::::0;3331:18:1;;44349:44:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;44448:10;::::0;44437:50:::1;::::0;-1:-1:-1;;;44437:50:0;;44476:10:::1;44437:50;::::0;::::1;3358:51:1::0;44333:60:0;;-1:-1:-1;44400:34:0::1;::::0;-1:-1:-1;;;;;44448:10:0;;::::1;::::0;44437:38:::1;::::0;3331:18:1;;44437:50:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;44437:50:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;44400:87;;44507:9;44502:387;44526:5;44522:1;:9;44502:387;;;44549:15;44567:7;44575:1;44567:10;;;;;;;;:::i;:::-;;;;;;;:13;;;44549:31;;44694:7;44702:1;44694:10;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;44670:21:::1;::::0;;;:12:::1;:21:::0;;;;;;;:34;;:21;;:34:::1;::::0;:21;:34:::1;:::i;:::-;-1:-1:-1::0;44670:34:0::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;;;-1:-1:-1;44775:19:0;;;:10:::1;:19:::0;;;;;::::1;;44770:71;;44809:18;:20:::0;;;:18:::1;:20;::::0;::::1;:::i;:::-;;;;;;44770:71;44853:19;::::0;;;:10:::1;:19;::::0;;;;:26;;-1:-1:-1;;44853:26:0::1;44875:4;44853:26;::::0;;44533:3;::::1;::::0;::::1;:::i;:::-;;;;44502:387;;;;44326:570;;28728:20:::0;28122:1;29248:22;;29065:213;28728:20;44282:614::o;50585:107::-;31593:13;:11;:13::i;:::-;50661:10:::1;:23:::0;50585:107::o;32348:103::-;31593:13;:11;:13::i;:::-;32413:30:::1;32440:1;32413:18;:30::i;51636:144::-:0;44229:5;;-1:-1:-1;;;;;44229:5:0;44215:10;:19;44207:47;;;;-1:-1:-1;;;44207:47:0;;;;;;;:::i;:::-;51690:6:::1;::::0;-1:-1:-1;;;51690:6:0;::::1;;;51689:7;51681:44;;;::::0;-1:-1:-1;;;51681:44:0;;14737:2:1;51681:44:0::1;::::0;::::1;14719:21:1::0;14776:2;14756:18;;;14749:30;14815:26;14795:18;;;14788:54;14859:18;;51681:44:0::1;14535:348:1::0;51681:44:0::1;51736:6;:13:::0;;-1:-1:-1;;;;51736:13:0::1;-1:-1:-1::0;;;51736:13:0::1;::::0;;51765:7:::1;::::0;::::1;::::0;51736:13;;51765:7:::1;51636:144::o:0;51428:180::-;31593:13;:11;:13::i;:::-;51562:38:::1;::::0;-1:-1:-1;;;51562:38:0;;51580:10:::1;51562:38;::::0;::::1;15062:51:1::0;15129:18;;;15122:34;;;51542:9:0;;-1:-1:-1;;;;;51562:17:0;::::1;::::0;::::1;::::0;15035:18:1;;51562:38:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;51513:95;51428:180:::0;;:::o;49909:564::-;31593:13;:11;:13::i;:::-;28684:21:::1;:19;:21::i;:::-;50191:191:::2;;;;;;;;50207:5;50191:191;;;;50223:3;50191:191;;;;50237:6;50191:191;;;;50254:7;50191:191;;;;50272:8;50191:191;;;;50291:7;50191:191;;;;50309:5;50191:191;;;;50325:7;50191:191;;;;50343:9;50191:191;;;;50363:8;50191:191;;::::0;50173:10:::2;:15;50184:3;50173:15;;;;;;;;;;;:209;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;50173:209:0::2;::::0;;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;;::::2;::::0;::::2;::::0;;::::2;::::0;;;;-1:-1:-1;50403:16:0;;;:11:::2;:16:::0;;;;:24;;;28728:20:::1;28122:1:::0;29248:22;;29065:213;28728:20:::1;49909:564:::0;;;;;;;;;;;:::o;51096:93::-;44229:5;;-1:-1:-1;;;;;44229:5:0;44215:10;:19;44207:47;;;;-1:-1:-1;;;44207:47:0;;;;;;;:::i;:::-;51164:5:::1;:17:::0;;-1:-1:-1;;;;;;51164:17:0::1;-1:-1:-1::0;;;;;51164:17:0;;;::::1;::::0;;;::::1;::::0;;51096:93::o;43363:43::-;;;;;;;;;;;;;;;;;;:::i;45469:3789::-;28684:21;:19;:21::i;:::-;45587:6:::1;::::0;-1:-1:-1;;;45587:6:0;::::1;;;45586:7;45578:35;;;::::0;-1:-1:-1;;;45578:35:0;;15651:2:1;45578:35:0::1;::::0;::::1;15633:21:1::0;15690:2;15670:18;;;15663:30;-1:-1:-1;;;15709:18:1;;;15702:45;15764:18;;45578:35:0::1;15449:339:1::0;45578:35:0::1;45687:10;::::0;45676:44:::1;::::0;-1:-1:-1;;;45676:44:0;;45709:10:::1;45676:44;::::0;::::1;3358:51:1::0;45660:13:0::1;::::0;-1:-1:-1;;;;;45687:10:0::1;::::0;45676:32:::1;::::0;3331:18:1;;45676:44:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45775:10;::::0;45764:50:::1;::::0;-1:-1:-1;;;45764:50:0;;45803:10:::1;45764:50;::::0;::::1;3358:51:1::0;45660:60:0;;-1:-1:-1;45727:34:0::1;::::0;-1:-1:-1;;;;;45775:10:0;;::::1;::::0;45764:38:::1;::::0;3331:18:1;;45764:50:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;45764:50:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;45727:87;;45832:9;45827:385;45851:5;45847:1;:9;45827:385;;;45874:15;45892:7;45900:1;45892:10;;;;;;;;:::i;:::-;;;;;;;:13;;;45874:31;;46017:7;46025:1;46017:10;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;45993:21:::1;::::0;;;:12:::1;:21:::0;;;;;;;:34;;:21;;:34:::1;::::0;:21;:34:::1;:::i;:::-;-1:-1:-1::0;45993:34:0::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;;;-1:-1:-1;46098:19:0;;;:10:::1;:19:::0;;;;;::::1;;46093:110;;46132:18;:20:::0;;;:18:::1;:20;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;46165:19:0::1;::::0;;;:10:::1;:19;::::0;;;;:26;;-1:-1:-1;;46165:26:0::1;46187:4;46165:26;::::0;;46093:110:::1;-1:-1:-1::0;45858:3:0;::::1;::::0;::::1;:::i;:::-;;;;45827:385;;;;46229:9;46224:3027;46244:16:::0;;::::1;46224:3027;;;46282:15;46300:5;;46306:1;46300:8;;;;;;;:::i;:::-;;;;;;;46282:26;;46396:21;46409:7;46396:12;:21::i;:::-;46388:43;;;::::0;-1:-1:-1;;;46388:43:0;;15995:2:1;46388:43:0::1;::::0;::::1;15977:21:1::0;16034:1;16014:18;;;16007:29;-1:-1:-1;;;16052:18:1;;;16045:39;16101:18;;46388:43:0::1;15793:332:1::0;46388:43:0::1;46559:8;::::0;46519:14:::1;46536:20:::0;;;:11:::1;:20;::::0;;;;;46519:14;;46536:31:::1;::::0;::::1;:::i;:::-;46519:48:::0;-1:-1:-1;46608:15:0::1;46646:20:::0;;::::1;46638:43;;;::::0;-1:-1:-1;;;46638:43:0;;16462:2:1;46638:43:0::1;::::0;::::1;16444:21:1::0;16501:2;16481:18;;;16474:30;-1:-1:-1;;;16520:18:1;;;16513:40;16570:18;;46638:43:0::1;16260:334:1::0;46638:43:0::1;46766:10;::::0;46755:43:::1;::::0;-1:-1:-1;;;46755:43:0;;::::1;::::0;::::1;160:25:1::0;;;-1:-1:-1;;;;;46766:10:0;;::::1;::::0;46755:34:::1;::::0;133:18:1;;46755:43:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46754:44;46746:72;;;::::0;-1:-1:-1;;;46746:72:0;;16801:2:1;46746:72:0::1;::::0;::::1;16783:21:1::0;16840:2;16820:18;;;16813:30;-1:-1:-1;;;16859:18:1;;;16852:45;16914:18;;46746:72:0::1;16599:339:1::0;46746:72:0::1;46920:1;46887:21:::0;;;:12:::1;:21;::::0;;;;:30:::1;;::::0;:34;46883:2357:::1;;46938:12;46952:22:::0;46976:16:::1;46994:13:::0;47023:14:::1;47039:12:::0;47053:15:::1;47070::::0;47167:1:::1;47144:11;:20;47156:7;47144:20;;;;;;;;;;;;:24;47140:322;;;47249:8;::::0;47225:20:::1;::::0;;;:11:::1;:20;::::0;;;;;47211:34:::1;::::0;:11;:34:::1;:::i;:::-;47210:47;;;;:::i;:::-;47203:54;;47140:322;;;47326:1;47314:8;;47301:9;;47287:11;:23;;;;:::i;:::-;47286:36;;;;:::i;:::-;47285:42;47281:181;;;47355:1;47348:8;;47281:181;;;47435:8;::::0;47422:9:::1;::::0;47408:23:::1;::::0;:11;:23:::1;:::i;:::-;47407:36;;;;:::i;:::-;47399:45;;47281:181;47536:13;::::0;47498:21:::1;::::0;;;:12:::1;:21;::::0;;;;:30:::1;;::::0;:34:::1;::::0;47531:1:::1;::::0;47498:34:::1;:::i;:::-;47497:52;;;;:::i;:::-;47618:10;::::0;47579:21:::1;::::0;;;:12:::1;:21;::::0;;;;:30:::1;;::::0;47480:69;;-1:-1:-1;47631:4:0;;47579:34:::1;::::0;47612:1:::1;::::0;47579:34:::1;:::i;:::-;47577:51;;;;:::i;:::-;:58;;;;:::i;:::-;47721:10;::::0;47692:19:::1;::::0;;;:10:::1;:19;::::0;;;;;;;:25:::1;::::0;;::::1;::::0;47662:12:::1;:21:::0;;;;;:27;;::::1;::::0;47566:69;;-1:-1:-1;47735:14:0;;47662:55:::1;::::0;47692:25;47662:55:::1;:::i;:::-;47661:70;;;;:::i;:::-;47660:89;;;;:::i;:::-;47817:19;::::0;;;:10:::1;:19;::::0;;;;;;;:26:::1;::::0;;::::1;::::0;47786:12:::1;:21:::0;;;;;:28;;::::1;::::0;47652:97;;-1:-1:-1;;47782:201:0::1;;;47936:11;::::0;47906:19:::1;::::0;;;:10:::1;:19;::::0;;;;;;;:26:::1;::::0;;::::1;::::0;47875:12:::1;:21:::0;;;;;:28;;::::1;::::0;47951:14;;47936:11;47875:57:::1;::::0;::::1;:::i;:::-;47874:73;;;;:::i;:::-;47873:92;;;;:::i;:::-;47864:101;;47782:201;48034:19;::::0;;;:10:::1;:19;::::0;;;;;;;:24:::1;::::0;;::::1;::::0;48005:12:::1;:21:::0;;;;;:26;;::::1;::::0;:53:::1;48001:187;;;48143:9;::::0;48115:19:::1;::::0;;;:10:::1;:19;::::0;;;;;;;:24:::1;::::0;;::::1;::::0;48086:12:::1;:21:::0;;;;;:26;;::::1;::::0;48156:14;;48143:9;48086:53:::1;::::0;::::1;:::i;:::-;48085:67;;;;:::i;:::-;48084:86;;;;:::i;:::-;48077:93;;48001:187;48281:12;::::0;48250:19:::1;::::0;;;:10:::1;:19;::::0;;;;;;;:27:::1;::::0;;::::1;::::0;48218:12:::1;:21:::0;;;;;:29;;::::1;::::0;48297:14;;48281:12;48218:59:::1;::::0;::::1;:::i;:::-;48217:76;;;;:::i;:::-;48216:95;;;;:::i;:::-;48385:7;::::0;48206:105;;-1:-1:-1;48206:105:0;48367:4;48358:6;48339:16:::1;48350:5:::0;48339:8;:16:::1;:::i;:::-;:25;;;;:::i;:::-;:32;;;;:::i;:::-;:42;;;;:::i;:::-;48338:54;;;;:::i;:::-;48492:9;::::0;:34:::1;::::0;-1:-1:-1;;;48492:34:0;;48520:4:::1;48492:34;::::0;::::1;3358:51:1::0;48328:64:0;;-1:-1:-1;48328:64:0;;-1:-1:-1;;;;;48492:9:0;;::::1;::::0;:19:::1;::::0;3331:18:1;;48492:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;48484:76;;;::::0;-1:-1:-1;;;48484:76:0;;17673:2:1;48484:76:0::1;::::0;::::1;17655:21:1::0;17712:2;17692:18;;;17685:30;-1:-1:-1;;;17731:18:1;;;17724:49;17790:18;;48484:76:0::1;17471:343:1::0;48484:76:0::1;48654:9;::::0;:39:::1;::::0;-1:-1:-1;;;48654:39:0;;48673:10:::1;48654:39;::::0;::::1;15062:51:1::0;15129:18;;;15122:34;;;-1:-1:-1;;;;;48654:9:0;;::::1;::::0;:18:::1;::::0;15035::1;;48654:39:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48646:67;;;::::0;-1:-1:-1;;;48646:67:0;;18021:2:1;48646:67:0::1;::::0;::::1;18003:21:1::0;18060:2;18040:18;;;18033:30;-1:-1:-1;;;18079:18:1;;;18072:45;18134:18;;48646:67:0::1;17819:339:1::0;48646:67:0::1;48767:22;48781:7;48767:13;:22::i;:::-;48853:20;::::0;;;:11:::1;:20;::::0;;;;:34;;;48984:19:::1;:30:::0;;49007:7;;48853:20;48984:30:::1;::::0;49007:7;;48984:30:::1;:::i;:::-;::::0;;;-1:-1:-1;;49076:41:0::1;::::0;160:25:1;;;49097:10:0::1;::::0;49076:41:::1;::::0;148:2:1;133:18;49076:41:0::1;;;;;;;46923:2210;;;;;;;;46883:2357;;;49199:1;49166:21:::0;;;:12:::1;:21;::::0;;;;:30:::1;;::::0;49158:66:::1;;;::::0;-1:-1:-1;;;49158:66:0;;18365:2:1;49158:66:0::1;::::0;::::1;18347:21:1::0;18404:2;18384:18;;;18377:30;-1:-1:-1;;;18423:18:1;;;18416:49;18482:18;;49158:66:0::1;18163:343:1::0;49158:66:0::1;46267:2984;;;46262:3;;;;;:::i;:::-;;;;46224:3027;;;;45533:3725;;28728:20:::0;28122:1;29248:22;;29065:213;28728:20;45469:3789;;:::o;32606:201::-;31593:13;:11;:13::i;:::-;-1:-1:-1;;;;;32695:22:0;::::1;32687:73;;;::::0;-1:-1:-1;;;32687:73:0;;18713:2:1;32687:73:0::1;::::0;::::1;18695:21:1::0;18752:2;18732:18;;;18725:30;18791:34;18771:18;;;18764:62;-1:-1:-1;;;18842:18:1;;;18835:36;18888:19;;32687:73:0::1;18511:402:1::0;32687:73:0::1;32771:28;32790:8;32771:18;:28::i;:::-;32606:201:::0;:::o;50793:295::-;31593:13;:11;:13::i;:::-;50931::::1;:25:::0;;;;50967:10:::1;:19:::0;;;;50997:9:::1;:17:::0;51025:11:::1;:21:::0;51057:12:::1;:23:::0;50793:295::o;31872:132::-;31753:7;31780:6;-1:-1:-1;;;;;31780:6:0;30338:10;31936:23;31928:68;;;;-1:-1:-1;;;31928:68:0;;19120:2:1;31928:68:0;;;19102:21:1;;;19139:18;;;19132:30;19198:34;19178:18;;;19171:62;19250:18;;31928:68:0;18918:356:1;28764:293:0;28166:1;28898:7;;:19;28890:63;;;;-1:-1:-1;;;28890:63:0;;19481:2:1;28890:63:0;;;19463:21:1;19520:2;19500:18;;;19493:30;19559:33;19539:18;;;19532:61;19610:18;;28890:63:0;19279:355:1;28890:63:0;28166:1;29031:7;:18;28764:293::o;32967:191::-;33041:16;33060:6;;-1:-1:-1;;;;;33077:17:0;;;-1:-1:-1;;;;;;33077:17:0;;;;;;33110:40;;33060:6;;;;;;;33110:40;;33041:16;33110:40;33030:128;32967:191;:::o;45112:349::-;45274:10;;45263:40;;-1:-1:-1;;;45263:40:0;;;;;160:25:1;;;45175:4:0;;;;-1:-1:-1;;;;;45274:10:0;;;;45263:30;;133:18:1;;45263:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45247:56;-1:-1:-1;45361:10:0;-1:-1:-1;;;;;45352:19:0;;;45348:73;;-1:-1:-1;45399:4:0;;45112:349;-1:-1:-1;;45112:349:0:o;45348:73::-;-1:-1:-1;45448:5:0;;45112:349;-1:-1:-1;;45112:349:0:o;49266:631::-;49389:36;49428:22;;;:12;:22;;;;;;49389:61;;;;;;;;;;;;49428:22;;49389:61;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49548:341;;;;;;;;49568:11;:16;;;49548:341;;;;49599:11;:14;;;49548:341;;;;49628:11;:17;;;49548:341;;;;49660:11;:18;;;49548:341;;;;49693:11;:19;;;49548:341;;;;49727:11;:18;;;49548:341;;;;49760:11;:16;;;49548:341;;;;49791:11;:18;;;49548:341;;;;49824:11;:20;;;49548:341;;;;49859:11;:19;;;49548:341;;;49525:10;:20;49536:8;49525:20;;;;;;;;;;;:364;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;49525:364:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49266:631:0:o;196:131:1:-;-1:-1:-1;;;;;271:31:1;;261:42;;251:70;;317:1;314;307:12;332:247;391:6;444:2;432:9;423:7;419:23;415:32;412:52;;;460:1;457;450:12;412:52;499:9;486:23;518:31;543:5;518:31;:::i;:::-;568:5;332:247;-1:-1:-1;;;332:247:1:o;584:180::-;643:6;696:2;684:9;675:7;671:23;667:32;664:52;;;712:1;709;702:12;664:52;-1:-1:-1;735:23:1;;584:180;-1:-1:-1;584:180:1:o;769:250::-;854:1;864:113;878:6;875:1;872:13;864:113;;;954:11;;;948:18;935:11;;;928:39;900:2;893:10;864:113;;;-1:-1:-1;;1011:1:1;993:16;;986:27;769:250::o;1024:271::-;1066:3;1104:5;1098:12;1131:6;1126:3;1119:19;1147:76;1216:6;1209:4;1204:3;1200:14;1193:4;1186:5;1182:16;1147:76;:::i;:::-;1277:2;1256:15;-1:-1:-1;;1252:29:1;1243:39;;;;1284:4;1239:50;;1024:271;-1:-1:-1;;1024:271:1:o;1300:1015::-;1477:2;1466:9;1459:21;1440:4;1515:6;1509:13;1541:6;1583:2;1578;1567:9;1563:18;1556:30;1609:52;1656:3;1645:9;1641:19;1627:12;1609:52;:::i;:::-;1595:66;;1715:2;1707:6;1703:15;1697:22;1692:2;1681:9;1677:18;1670:50;1774:2;1766:6;1762:15;1756:22;1751:2;1740:9;1736:18;1729:50;1834:2;1826:6;1822:15;1816:22;1810:3;1799:9;1795:19;1788:51;1894:3;1886:6;1882:16;1876:23;1870:3;1859:9;1855:19;1848:52;1955:3;1947:6;1943:16;1937:23;1931:3;1920:9;1916:19;1909:52;2016:3;2008:6;2004:16;1998:23;1992:3;1981:9;1977:19;1970:52;2059:3;2051:6;2047:16;2041:23;2083:3;2122:2;2117;2106:9;2102:18;2095:30;2162:2;2154:6;2150:15;2144:22;2134:32;;;2185:3;2224:2;2219;2208:9;2204:18;2197:30;2281:2;2273:6;2269:15;2263:22;2258:2;2247:9;2243:18;2236:50;;;;2303:6;2295:14;;;1300:1015;;;;:::o;2320:887::-;2684:4;2713:3;2743:2;2732:9;2725:21;2763:45;2804:2;2793:9;2789:18;2781:6;2763:45;:::i;:::-;2839:2;2824:18;;2817:34;;;;-1:-1:-1;;2882:2:1;2867:18;;2860:34;;;;2925:2;2910:18;;2903:34;;;;2968:3;2953:19;;2946:35;;;;3012:3;2997:19;;2990:35;;;;3056:3;3041:19;;3034:35;3100:3;3085:19;;3078:35;3144:3;3129:19;;3122:35;3188:3;3173:19;;;3166:35;2755:53;2320:887;-1:-1:-1;2320:887:1:o;3612:330::-;3695:6;3703;3756:2;3744:9;3735:7;3731:23;3727:32;3724:52;;;3772:1;3769;3762:12;3724:52;3811:9;3798:23;3830:31;3855:5;3830:31;:::i;:::-;3880:5;3932:2;3917:18;;;;3904:32;;-1:-1:-1;;;3612:330:1:o;4170:127::-;4231:10;4226:3;4222:20;4219:1;4212:31;4262:4;4259:1;4252:15;4286:4;4283:1;4276:15;4302:255;4374:2;4368:9;4416:6;4404:19;;4453:18;4438:34;;4474:22;;;4435:62;4432:88;;;4500:18;;:::i;:::-;4536:2;4529:22;4302:255;:::o;4562:275::-;4633:2;4627:9;4698:2;4679:13;;-1:-1:-1;;4675:27:1;4663:40;;4733:18;4718:34;;4754:22;;;4715:62;4712:88;;;4780:18;;:::i;:::-;4816:2;4809:22;4562:275;;-1:-1:-1;4562:275:1:o;4842:187::-;4891:4;4924:18;4916:6;4913:30;4910:56;;;4946:18;;:::i;:::-;-1:-1:-1;5012:2:1;4991:15;-1:-1:-1;;4987:29:1;5018:4;4983:40;;4842:187::o;5034:1373::-;5193:6;5201;5209;5217;5225;5233;5241;5249;5257;5265;5273:7;5327:3;5315:9;5306:7;5302:23;5298:33;5295:53;;;5344:1;5341;5334:12;5295:53;5384:9;5371:23;5417:18;5409:6;5406:30;5403:50;;;5449:1;5446;5439:12;5403:50;5472:22;;5525:4;5517:13;;5513:27;-1:-1:-1;5503:55:1;;5554:1;5551;5544:12;5503:55;5590:2;5577:16;5615:49;5631:32;5660:2;5631:32;:::i;:::-;5615:49;:::i;:::-;5687:2;5680:5;5673:17;5729:7;5722:4;5717:2;5713;5709:11;5705:22;5702:35;5699:55;;;5750:1;5747;5740:12;5699:55;5809:2;5802:4;5798:2;5794:13;5787:4;5780:5;5776:16;5763:49;5855:1;5848:4;5832:14;;;5828:25;;5821:36;5832:14;5913:20;;;5900:34;;-1:-1:-1;5981:2:1;5966:18;;5953:32;;6032:2;6017:18;;6004:32;;-1:-1:-1;6083:3:1;6068:19;;6055:33;;-1:-1:-1;6135:3:1;6120:19;;6107:33;;-1:-1:-1;6187:3:1;6172:19;;6159:33;;-1:-1:-1;6239:3:1;6224:19;;6211:33;;-1:-1:-1;6291:3:1;6276:19;;6263:33;;-1:-1:-1;6343:3:1;6328:19;;6315:33;;-1:-1:-1;6396:3:1;6381:19;6368:33;;-1:-1:-1;5836:5:1;-1:-1:-1;;;;5034:1373:1:o;6412:615::-;6498:6;6506;6559:2;6547:9;6538:7;6534:23;6530:32;6527:52;;;6575:1;6572;6565:12;6527:52;6615:9;6602:23;6644:18;6685:2;6677:6;6674:14;6671:34;;;6701:1;6698;6691:12;6671:34;6739:6;6728:9;6724:22;6714:32;;6784:7;6777:4;6773:2;6769:13;6765:27;6755:55;;6806:1;6803;6796:12;6755:55;6846:2;6833:16;6872:2;6864:6;6861:14;6858:34;;;6888:1;6885;6878:12;6858:34;6941:7;6936:2;6926:6;6923:1;6919:14;6915:2;6911:23;6907:32;6904:45;6901:65;;;6962:1;6959;6952:12;6901:65;6993:2;6985:11;;;;;7015:6;;-1:-1:-1;6412:615:1;;-1:-1:-1;;;;6412:615:1:o;7032:454::-;7127:6;7135;7143;7151;7159;7212:3;7200:9;7191:7;7187:23;7183:33;7180:53;;;7229:1;7226;7219:12;7180:53;-1:-1:-1;;7252:23:1;;;7322:2;7307:18;;7294:32;;-1:-1:-1;7373:2:1;7358:18;;7345:32;;7424:2;7409:18;;7396:32;;-1:-1:-1;7475:3:1;7460:19;7447:33;;-1:-1:-1;7032:454:1;-1:-1:-1;7032:454:1:o;7491:339::-;7693:2;7675:21;;;7732:2;7712:18;;;7705:30;-1:-1:-1;;;7766:2:1;7751:18;;7744:45;7821:2;7806:18;;7491:339::o;8183:380::-;8262:1;8258:12;;;;8305;;;8326:61;;8380:4;8372:6;8368:17;8358:27;;8326:61;8433:2;8425:6;8422:14;8402:18;8399:38;8396:161;;8479:10;8474:3;8470:20;8467:1;8460:31;8514:4;8511:1;8504:15;8542:4;8539:1;8532:15;8396:161;;8183:380;;;:::o;8917:184::-;8987:6;9040:2;9028:9;9019:7;9015:23;9011:32;9008:52;;;9056:1;9053;9046:12;9008:52;-1:-1:-1;9079:16:1;;8917:184;-1:-1:-1;8917:184:1:o;9106:443::-;9160:5;9213:3;9206:4;9198:6;9194:17;9190:27;9180:55;;9231:1;9228;9221:12;9180:55;9260:6;9254:13;9291:49;9307:32;9336:2;9307:32;:::i;9291:49::-;9365:2;9356:7;9349:19;9411:3;9404:4;9399:2;9391:6;9387:15;9383:26;9380:35;9377:55;;;9428:1;9425;9418:12;9377:55;9441:77;9515:2;9508:4;9499:7;9495:18;9488:4;9480:6;9476:17;9441:77;:::i;:::-;9536:7;9106:443;-1:-1:-1;;;;9106:443:1:o;9554:2368::-;9673:6;9704:2;9747;9735:9;9726:7;9722:23;9718:32;9715:52;;;9763:1;9760;9753:12;9715:52;9796:9;9790:16;9825:18;9866:2;9858:6;9855:14;9852:34;;;9882:1;9879;9872:12;9852:34;9920:6;9909:9;9905:22;9895:32;;9965:7;9958:4;9954:2;9950:13;9946:27;9936:55;;9987:1;9984;9977:12;9936:55;10016:2;10010:9;10038:2;10034;10031:10;10028:36;;;10044:18;;:::i;:::-;10090:2;10087:1;10083:10;10113:28;10137:2;10133;10129:11;10113:28;:::i;:::-;10175:15;;;10245:11;;;10241:20;;;10206:12;;;;10273:19;;;10270:39;;;10305:1;10302;10295:12;10270:39;10337:2;10333;10329:11;10318:22;;10349:1543;10365:6;10360:3;10357:15;10349:1543;;;10444:3;10438:10;10480:2;10467:11;10464:19;10461:109;;;10524:1;10553:2;10549;10542:14;10461:109;10593:20;;10636:6;10666:16;;;-1:-1:-1;;10662:30:1;10658:39;-1:-1:-1;10655:129:1;;;10738:1;10767:2;10763;10756:14;10655:129;10810:22;;:::i;:::-;10875:2;10871;10867:11;10861:18;10908:2;10898:8;10895:16;10892:109;;;10953:1;10983:3;10978;10971:16;10892:109;11028:65;11085:7;11080:2;11069:8;11065:2;11061:17;11057:26;11028:65;:::i;:::-;11021:5;11014:80;;11118:2;11170:3;11166:2;11162:12;11156:19;11151:2;11144:5;11140:14;11133:43;11200:2;11253:3;11249:2;11245:12;11239:19;11233:3;11226:5;11222:15;11215:44;11283:3;11272:14;;11337:3;11333:2;11329:12;11323:19;11317:3;11310:5;11306:15;11299:44;;11367:3;11421;11417:2;11413:12;11407:19;11401:3;11394:5;11390:15;11383:44;11451:3;11440:14;;11505:3;11501:2;11497:12;11491:19;11485:3;11478:5;11474:15;11467:44;;11535:3;11589;11585:2;11581:12;11575:19;11569:3;11562:5;11558:15;11551:44;11619:3;11608:14;;11673:3;11669:2;11665:12;11659:19;11653:3;11646:5;11642:15;11635:44;;11703:3;11757;11753:2;11749:12;11743:19;11737:3;11730:5;11726:15;11719:44;11814:2;11810;11806:11;11800:18;11794:3;11787:5;11783:15;11776:43;;;11844:5;11839:3;11832:18;;;;11879:2;11874:3;11870:12;11863:19;;10391:2;10386:3;10382:12;10375:19;;10349:1543;;;11911:5;9554:2368;-1:-1:-1;;;;;;;;;9554:2368:1:o;11927:127::-;11988:10;11983:3;11979:20;11976:1;11969:31;12019:4;12016:1;12009:15;12043:4;12040:1;12033:15;12185:545;12287:2;12282:3;12279:11;12276:448;;;12323:1;12348:5;12344:2;12337:17;12393:4;12389:2;12379:19;12463:2;12451:10;12447:19;12444:1;12440:27;12434:4;12430:38;12499:4;12487:10;12484:20;12481:47;;;-1:-1:-1;12522:4:1;12481:47;12577:2;12572:3;12568:12;12565:1;12561:20;12555:4;12551:31;12541:41;;12632:82;12650:2;12643:5;12640:13;12632:82;;;12695:17;;;12676:1;12665:13;12632:82;;;12636:3;;;12276:448;12185:545;;;:::o;12906:1352::-;13032:3;13026:10;13059:18;13051:6;13048:30;13045:56;;;13081:18;;:::i;:::-;13110:97;13200:6;13160:38;13192:4;13186:11;13160:38;:::i;:::-;13154:4;13110:97;:::i;:::-;13262:4;;13326:2;13315:14;;13343:1;13338:663;;;;14045:1;14062:6;14059:89;;;-1:-1:-1;14114:19:1;;;14108:26;14059:89;-1:-1:-1;;12863:1:1;12859:11;;;12855:24;12851:29;12841:40;12887:1;12883:11;;;12838:57;14161:81;;13308:944;;13338:663;12132:1;12125:14;;;12169:4;12156:18;;-1:-1:-1;;13374:20:1;;;13492:236;13506:7;13503:1;13500:14;13492:236;;;13595:19;;;13589:26;13574:42;;13687:27;;;;13655:1;13643:14;;;;13522:19;;13492:236;;;13496:3;13756:6;13747:7;13744:19;13741:201;;;13817:19;;;13811:26;-1:-1:-1;;13900:1:1;13896:14;;;13912:3;13892:24;13888:37;13884:42;13869:58;13854:74;;13741:201;-1:-1:-1;;;;;13988:1:1;13972:14;;;13968:22;13955:36;;-1:-1:-1;12906:1352:1:o;14263:127::-;14324:10;14319:3;14315:20;14312:1;14305:31;14355:4;14352:1;14345:15;14379:4;14376:1;14369:15;14395:135;14434:3;14455:17;;;14452:43;;14475:18;;:::i;:::-;-1:-1:-1;14522:1:1;14511:13;;14395:135::o;15167:277::-;15234:6;15287:2;15275:9;15266:7;15262:23;15258:32;15255:52;;;15303:1;15300;15293:12;15255:52;15335:9;15329:16;15388:5;15381:13;15374:21;15367:5;15364:32;15354:60;;15410:1;15407;15400:12;16130:125;16195:9;;;16216:10;;;16213:36;;;16229:18;;:::i;:::-;16130:125;;;;:::o;16943:128::-;17010:9;;;17031:11;;;17028:37;;;17045:18;;:::i;17076:217::-;17116:1;17142;17132:132;;17186:10;17181:3;17177:20;17174:1;17167:31;17221:4;17218:1;17211:15;17249:4;17246:1;17239:15;17132:132;-1:-1:-1;17278:9:1;;17076:217::o;17298:168::-;17371:9;;;17402;;17419:15;;;17413:22;;17399:37;17389:71;;17440:18;;:::i;19639:251::-;19709:6;19762:2;19750:9;19741:7;19737:23;19733:32;19730:52;;;19778:1;19775;19768:12;19730:52;19810:9;19804:16;19829:31;19854:5;19829:31;:::i

ipfs://0e7228166cb484b07a3cc6c866d6cec132338b1368fa932dd8fdeadc01c7ca27