Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IIdleRebalancerV3
•    - function getAllocations()
•    - function setAllocations(uint256[] cal ...
•  contract Context
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•  contract IdleRebalancerV3_1 is IId ... *
•    - function setRebalancerManager(address ...
•    - function setIdleToken(address _idleTo ...
•    - function setNewToken(address _newToke ...
•    - function setAllocations(uint256[] cal ...
•    - function getAllocations()
•    - function getAllocationsLength()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// File: contracts/interfaces/IIdleRebalancerV3.sol

/**
 * @title: Idle Rebalancer interface
 * @author: Idle Labs Inc., idle.finance
 */
pragma solidity 0.5.16;

interface IIdleRebalancerV3 {
  function getAllocations() external view returns (uint256[] memory _allocations);
  function setAllocations(uint256[] calldata _allocations, address[] calldata _addresses) external;
}

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

pragma solidity ^0.5.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

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

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

pragma solidity ^0.5.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.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

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

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

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

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

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.5.0;

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

// File: contracts/IdleRebalancerV3_1.sol

/**
 * @title: Idle Rebalancer contract
 * @summary: Used for calculating amounts to lend on each implemented protocol.
 *           This implementation works with Compound and Fulcrum only,
 *           when a new protocol will be added this should be replaced
 * @author: Idle Labs Inc., idle.finance
 */
pragma solidity 0.5.16;




contract IdleRebalancerV3_1 is IIdleRebalancerV3, Ownable {
  using SafeMath for uint256;
  uint256[] public lastAmounts;
  address[] public lastAmountsAddresses;
  address public rebalancerManager;
  address public idleToken;
  uint256 private constant MAX_PERC = 100000;

  /**
   * @param _protocolTokens : array of interest bearing tokens
   * @param _rebalancerManager : rebalancerManager address
   */
  constructor(address[] memory _protocolTokens, address _rebalancerManager) public {
    require(_rebalancerManager != address(0), 'manager addr is 0');
    rebalancerManager = _rebalancerManager;
    lastAmounts = new uint256[](_protocolTokens.length);
    lastAmountsAddresses = new address[](_protocolTokens.length);

    lastAmounts[0] = MAX_PERC;
    lastAmountsAddresses[0] = _protocolTokens[0];
    for(uint256 i = 1; i < _protocolTokens.length; i++) {
      require(_protocolTokens[i] != address(0), 'some addr is 0');
      // Initially 100% on first lending protocol
      lastAmountsAddresses[i] = _protocolTokens[i];
    }
  }

  /**
   * Throws if called by any account other than rebalancerManager.
   */
  modifier onlyRebalancerAndIdle() {
    require(msg.sender == rebalancerManager || msg.sender == idleToken, "Only rebalacer and IdleToken");
    _;
  }

  /**
   * It allows owner to set the allowed rebalancer address
   *
   * @param _rebalancerManager : rebalance manager address
   */
  function setRebalancerManager(address _rebalancerManager)
    external onlyOwner {
      require(_rebalancerManager != address(0), "_rebalancerManager addr is 0");

      rebalancerManager = _rebalancerManager;
  }

  function setIdleToken(address _idleToken)
    external onlyOwner {
      require(idleToken == address(0), "idleToken addr already set");
      require(_idleToken != address(0), "_idleToken addr is 0");
      idleToken = _idleToken;
  }

  /**
   * It adds a new token address to lastAmountsAddresses list
   *
   * @param _newToken : new interest bearing token address
   */
  function setNewToken(address _newToken)
    external onlyOwner {
      require(_newToken != address(0), "New token should be != 0");
      for (uint256 i = 0; i < lastAmountsAddresses.length; i++) {
        if (lastAmountsAddresses[i] == _newToken) {
          return;
        }
      }

      lastAmountsAddresses.push(_newToken);
      lastAmounts.push(0);
  }
  // end onlyOwner

  /**
   * Used by Rebalance manager to set the new allocations
   *
   * @param _allocations : array with allocations in percentages (100% => MAX_PERC)
   * @param _addresses : array with addresses of tokens used, should be equal to lastAmountsAddresses
   */
  function setAllocations(uint256[] calldata _allocations, address[] calldata _addresses)
    external onlyRebalancerAndIdle
  {
    require(_allocations.length == lastAmounts.length, "Alloc lengths are different, allocations");
    require(_allocations.length == _addresses.length, "Alloc lengths are different, addresses");

    uint256 total;
    for (uint256 i = 0; i < _allocations.length; i++) {
      require(_addresses[i] == lastAmountsAddresses[i], "Addresses do not match");
      total = total.add(_allocations[i]);
      lastAmounts[i] = _allocations[i];
    }
    require(total == MAX_PERC, "Not allocating 100%");
  }

  function getAllocations()
    external view returns (uint256[] memory _allocations) {
    return lastAmounts;
  }

  function getAllocationsLength()
    external view returns (uint256) {
    return lastAmounts.length;
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address[]","name":"_protocolTokens","type":"address[]"},{"internalType":"address","name":"_rebalancerManager","type":"address"}],"payable":false,"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"},{"constant":true,"inputs":[],"name":"getAllocations","outputs":[{"internalType":"uint256[]","name":"_allocations","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getAllocationsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"idleToken","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lastAmounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lastAmountsAddresses","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rebalancerManager","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256[]","name":"_allocations","type":"uint256[]"},{"internalType":"address[]","name":"_addresses","type":"address[]"}],"name":"setAllocations","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_idleToken","type":"address"}],"name":"setIdleToken","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_newToken","type":"address"}],"name":"setNewToken","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_rebalancerManager","type":"address"}],"name":"setRebalancerManager","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

9961:3618:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9961:3618:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10167:24;;;:::i;:::-;;;;;;;;;;;;;;;;;;;10130:32;;;:::i;10088:37::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;10088:37:0;;:::i;12033:373::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;12033:373:0;;;;:::i;:::-;;13347:116;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;13347:116:0;;;;;;;;;;;;;;;;;3313:140;;;:::i;2502:79::-;;;:::i;2868:94::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;13469:107;;;:::i;:::-;;;;;;;;;;;;;;;;11644:240;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;11644:240:0;;;;:::i;12699:642::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;12699:642:0;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;12699:642:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;12699:642: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;12699:642:0;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;12699:642:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;12699:642: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;-1:-1;12699:642:0;;-1:-1:-1;12699:642:0;-1:-1:-1;12699:642:0;:::i;10055:28::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;10055:28:0;;:::i;11419:219::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;11419:219:0;;;;:::i;3608:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3608:109:0;;;;:::i;10167:24::-;;;;;;:::o;10130:32::-;;;;;;:::o;10088:37::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10088:37:0;:::o;12033:373::-;2714:9;:7;:9::i;:::-;2706:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12114:23;;;12106:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12180:9;12175:151;12199:20;:27;12195:31;;12175:151;;;12275:9;12248:36;;:20;12269:1;12248:23;;;;;;;;;;;;;;;;;;;;:36;12244:73;;;12299:7;;;12244:73;12228:3;;12175:151;;;-1:-1:-1;12336:20:0;27:10:-1;;39:1;23:18;;;45:23;;;12336:36:0;;;;;;;;;;;;27:10:-1;;23:18;;;45:23;;-1:-1;12381:19:0;;;;;;2771:1;12033:373;:::o;13347:116::-;13401:29;13446:11;13439:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13347:116;:::o;3313:140::-;2714:9;:7;:9::i;:::-;2706:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3412:1;3396:6;;3375:40;;;3396:6;;;;3375:40;;3412:1;;3375:40;3443:1;3426:19;;;;;;3313:140::o;2502:79::-;2540:7;2567:6;;;2502:79;:::o;2868:94::-;2908:4;2948:6;;;;2932:12;:10;:12::i;:::-;:22;;;2925:29;;2868:94;:::o;13469:107::-;13552:11;:18;13469:107;:::o;11644:240::-;2714:9;:7;:9::i;:::-;2706:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11727:9;;:23;:9;:23;11719:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11798:24;;;11790:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11856:9;:22;;;;;;;;;;;;;;;11644:240::o;12699:642::-;11182:17;;;;11168:10;:31;;:58;;-1:-1:-1;11217:9:0;;;;11203:10;:23;11168:58;11160:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12864:11;:18;12841:41;;12833:94;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12942:40;;;12934:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13034:13;;13054:226;13074:23;;;13054:226;;;13138:20;13159:1;13138:23;;;;;;;;;;;;;;;;;;;;13121:10;;13132:1;13121:13;;;;;;;;;;;;;;;:40;;;13113:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13205:26;13215:12;;13228:1;13215:15;;;;;;;;;;;;;13205:5;:9;;:26;;;;:::i;:::-;13197:34;;13257:12;;13270:1;13257:15;;;;;;;;;;;;;13240:11;13252:1;13240:14;;;;;;;;;;;;;;;;;:32;13099:3;;13054:226;;;;10232:6;13294:5;:17;13286:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11266:1;12699:642;;;;:::o;10055:28::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10055:28:0;:::o;11419:219::-;2714:9;:7;:9::i;:::-;2706:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11518:32;;;11510:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11594:17;:38;;;;;;;;;;;;;;;11419:219::o;3608:109::-;2714:9;:7;:9::i;:::-;2706:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3681:28;3700:8;3681:18;:28::i;1251:98::-;1331:10;1251:98;:::o;4972:181::-;5030:7;5062:5;;;5086:6;;;;5078:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5144:1;4972:181;-1:-1:-1;;;4972:181:0:o;3823:229::-;3897:22;;;3889:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3999:6;;;3978:38;;;;;;;3999:6;;;3978:38;;;4027:6;:17;;;;;;;;;;;;;;;3823:229::o

bzzr://cbb5d192b767be122180b6b34ea1323613f34d977e751b0197297f141a7c65bd