Address Details
contract

0x19F78d207493Bf6f7E8D54900d01bb387F211b28

Contract Name
Governance
Creator
0xf3eb91–a79239 at 0x4f6b5b–39e366
Balance
0 CELO ( )
Locked CELO Balance
0.00 CELO
Voting CELO Balance
0.00 CELO
Pending Unlocked Gold
0.00 CELO
Tokens
Fetching tokens...
Transactions
2 Transactions
Transfers
1 Transfers
Gas Used
63,284
Last Balance Update
29258023
This contract has been verified via Sourcify. View contract in Sourcify repository
Contract name:
Governance




Optimization enabled
false
Compiler version
v0.5.13+commit.5b0b510c




EVM Version
istanbul




Verified at
2024-03-15T09:47:08.613287Z

project:/contracts/governance/Governance.sol

pragma solidity ^0.5.13;

import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/math/Math.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "openzeppelin-solidity/contracts/utils/Address.sol";

import "./interfaces/IGovernance.sol";
import "./Proposals.sol";
import "../common/interfaces/IAccounts.sol";
import "../common/ExtractFunctionSignature.sol";
import "../common/Initializable.sol";
import "../common/FixidityLib.sol";
import "../common/linkedlists/IntegerSortedLinkedList.sol";
import "../common/UsingRegistry.sol";
import "../common/UsingPrecompiles.sol";
import "../common/interfaces/ICeloVersionedContract.sol";
import "../common/libraries/ReentrancyGuard.sol";

/**
 * @title A contract for making, passing, and executing on-chain governance proposals.
 */
contract Governance is
  IGovernance,
  ICeloVersionedContract,
  Ownable,
  Initializable,
  ReentrancyGuard,
  UsingRegistry,
  UsingPrecompiles
{
  using Proposals for Proposals.Proposal;
  using FixidityLib for FixidityLib.Fraction;
  using SafeMath for uint256;
  using IntegerSortedLinkedList for SortedLinkedList.List;
  using BytesLib for bytes;
  using Address for address payable; // prettier-ignore

  uint256 private constant FIXED_HALF = 500000000000000000000000;

  enum VoteValue { None, Abstain, No, Yes }

  struct UpvoteRecord {
    uint256 proposalId;
    uint256 weight;
  }

  struct VoteRecord {
    Proposals.VoteValue deprecated_value; // obsolete
    uint256 proposalId;
    uint256 deprecated_weight; // obsolete
    uint256 yesVotes;
    uint256 noVotes;
    uint256 abstainVotes;
  }

  struct Voter {
    // Key of the proposal voted for in the proposal queue
    UpvoteRecord upvote;
    uint256 mostRecentReferendumProposal;
    // Maps a `dequeued` index to a voter's vote record.
    mapping(uint256 => VoteRecord) referendumVotes;
  }

  struct ContractConstitution {
    FixidityLib.Fraction defaultThreshold;
    // Maps a function ID to a corresponding threshold, overriding the default.
    mapping(bytes4 => FixidityLib.Fraction) functionThresholds;
  }

  struct HotfixRecord {
    bool executed;
    bool approved;
    uint256 preparedEpoch;
    mapping(address => bool) whitelisted;
  }

  // The baseline is updated as
  // max{floor, (1 - baselineUpdateFactor) * baseline + baselineUpdateFactor * participation}
  struct ParticipationParameters {
    // The average network participation in governance, weighted toward recent proposals.
    FixidityLib.Fraction baseline;
    // The lower bound on the participation baseline.
    FixidityLib.Fraction baselineFloor;
    // The weight of the most recent proposal's participation on the baseline.
    FixidityLib.Fraction baselineUpdateFactor;
    // The proportion of the baseline that constitutes quorum.
    FixidityLib.Fraction baselineQuorumFactor;
  }

  Proposals.StageDurations public stageDurations;
  uint256 public queueExpiry;
  uint256 public dequeueFrequency;
  address public approver;
  uint256 public lastDequeue;
  uint256 public concurrentProposals;
  uint256 public proposalCount;
  uint256 public minDeposit;
  mapping(address => uint256) public refundedDeposits;
  mapping(address => ContractConstitution) private constitution;
  mapping(uint256 => Proposals.Proposal) private proposals;
  mapping(address => Voter) internal voters;
  mapping(bytes32 => HotfixRecord) public hotfixes;
  SortedLinkedList.List private queue;
  uint256[] public dequeued;
  uint256[] public emptyIndices;
  ParticipationParameters private participationParameters;

  event ApproverSet(address indexed approver);

  event ConcurrentProposalsSet(uint256 concurrentProposals);

  event MinDepositSet(uint256 minDeposit);

  event QueueExpirySet(uint256 queueExpiry);

  event DequeueFrequencySet(uint256 dequeueFrequency);

  event ReferendumStageDurationSet(uint256 referendumStageDuration);

  event ExecutionStageDurationSet(uint256 executionStageDuration);

  event ConstitutionSet(address indexed destination, bytes4 indexed functionId, uint256 threshold);

  event ProposalQueued(
    uint256 indexed proposalId,
    address indexed proposer,
    uint256 transactionCount,
    uint256 deposit,
    uint256 timestamp
  );

  event ProposalUpvoted(uint256 indexed proposalId, address indexed account, uint256 upvotes);

  event ProposalUpvoteRevoked(
    uint256 indexed proposalId,
    address indexed account,
    uint256 revokedUpvotes
  );

  event ProposalDequeued(uint256 indexed proposalId, uint256 timestamp);

  event ProposalApproved(uint256 indexed proposalId);

  event ProposalVoted(
    uint256 indexed proposalId,
    address indexed account,
    uint256 value,
    uint256 weight
  );

  event ProposalVotedV2(
    uint256 indexed proposalId,
    address indexed account,
    uint256 yesVotes,
    uint256 noVotes,
    uint256 abstainVotes
  );

  event ProposalVoteRevoked(
    uint256 indexed proposalId,
    address indexed account,
    uint256 value,
    uint256 weight
  );

  event ProposalVoteRevokedV2(
    uint256 indexed proposalId,
    address indexed account,
    uint256 yesVotes,
    uint256 noVotes,
    uint256 abstainVotes
  );

  event ProposalExecuted(uint256 indexed proposalId);

  event ProposalExpired(uint256 indexed proposalId);

  event ParticipationBaselineUpdated(uint256 participationBaseline);

  event ParticipationFloorSet(uint256 participationFloor);

  event ParticipationBaselineUpdateFactorSet(uint256 baselineUpdateFactor);

  event ParticipationBaselineQuorumFactorSet(uint256 baselineQuorumFactor);

  event HotfixWhitelisted(bytes32 indexed hash, address whitelister);

  event HotfixApproved(bytes32 indexed hash);

  event HotfixPrepared(bytes32 indexed hash, uint256 indexed epoch);

  event HotfixExecuted(bytes32 indexed hash);

  modifier hotfixNotExecuted(bytes32 hash) {
    require(!hotfixes[hash].executed, "hotfix already executed");
    _;
  }

  modifier onlyApprover() {
    require(msg.sender == approver, "msg.sender not approver");
    _;
  }

  modifier onlyLockedGold() {
    require(msg.sender == address(getLockedGold()), "msg.sender not lockedGold");
    _;
  }

  /**
   * @notice Sets initialized == true on implementation contracts
   * @param test Set to true to skip implementation initialization
   */
  constructor(bool test) public Initializable(test) {}

  function() external payable {
    require(msg.data.length == 0, "unknown method");
  }

  /**
   * @notice Returns the storage, major, minor, and patch version of the contract.
   * @return Storage version of the contract.
   * @return Major version of the contract.
   * @return Minor version of the contract.
   * @return Patch version of the contract.
   */
  function getVersionNumber() external pure returns (uint256, uint256, uint256, uint256) {
    return (1, 4, 1, 0);
  }

  /**
   * @notice Used in place of the constructor to allow the contract to be upgradable via proxy.
   * @param registryAddress The address of the registry contract.
   * @param _approver The address that needs to approve proposals to move to the referendum stage.
   * @param _concurrentProposals The number of proposals to dequeue at once.
   * @param _minDeposit The minimum CELO deposit needed to make a proposal.
   * @param _queueExpiry The number of seconds a proposal can stay in the queue before expiring.
   * @param _dequeueFrequency The number of seconds before the next batch of proposals can be
   *   dequeued.
   * @param referendumStageDuration The number of seconds users have to vote on a dequeued proposal
   *   after the approval stage ends.
   * @param executionStageDuration The number of seconds users have to execute a passed proposal
   *   after the referendum stage ends.
   * @param participationBaseline The initial value of the participation baseline.
   * @param participationFloor The participation floor.
   * @param baselineUpdateFactor The weight of the new participation in the baseline update rule.
   * @param baselineQuorumFactor The proportion of the baseline that constitutes quorum.
   * @dev Should be called only once.
   */
  function initialize(
    address registryAddress,
    address _approver,
    uint256 _concurrentProposals,
    uint256 _minDeposit,
    uint256 _queueExpiry,
    uint256 _dequeueFrequency,
    uint256 referendumStageDuration,
    uint256 executionStageDuration,
    uint256 participationBaseline,
    uint256 participationFloor,
    uint256 baselineUpdateFactor,
    uint256 baselineQuorumFactor
  ) external initializer {
    _transferOwnership(msg.sender);
    setRegistry(registryAddress);
    setApprover(_approver);
    setConcurrentProposals(_concurrentProposals);
    setMinDeposit(_minDeposit);
    setQueueExpiry(_queueExpiry);
    setDequeueFrequency(_dequeueFrequency);
    setReferendumStageDuration(referendumStageDuration);
    setExecutionStageDuration(executionStageDuration);
    setParticipationBaseline(participationBaseline);
    setParticipationFloor(participationFloor);
    setBaselineUpdateFactor(baselineUpdateFactor);
    setBaselineQuorumFactor(baselineQuorumFactor);
    // solhint-disable-next-line not-rely-on-time
    lastDequeue = now;
  }

  /**
   * @notice Updates the address that has permission to approve proposals in the approval stage.
   * @param _approver The address that has permission to approve proposals in the approval stage.
   */
  function setApprover(address _approver) public onlyOwner {
    require(_approver != address(0), "Approver cannot be 0");
    require(_approver != approver, "Approver unchanged");
    approver = _approver;
    emit ApproverSet(_approver);
  }

  /**
   * @notice Updates the number of proposals to dequeue at a time.
   * @param _concurrentProposals The number of proposals to dequeue at at a time.
   */
  function setConcurrentProposals(uint256 _concurrentProposals) public onlyOwner {
    require(_concurrentProposals != 0, "Number of proposals must be larger than zero");
    require(_concurrentProposals != concurrentProposals, "Number of proposals unchanged");
    concurrentProposals = _concurrentProposals;
    emit ConcurrentProposalsSet(_concurrentProposals);
  }

  /**
   * @notice Updates the minimum deposit needed to make a proposal.
   * @param _minDeposit The minimum CELO deposit needed to make a proposal.
   */
  function setMinDeposit(uint256 _minDeposit) public onlyOwner {
    require(_minDeposit != 0, "minDeposit must be larger than 0");
    require(_minDeposit != minDeposit, "Minimum deposit unchanged");
    minDeposit = _minDeposit;
    emit MinDepositSet(_minDeposit);
  }

  /**
   * @notice Updates the number of seconds before a queued proposal expires.
   * @param _queueExpiry The number of seconds a proposal can stay in the queue before expiring.
   */
  function setQueueExpiry(uint256 _queueExpiry) public onlyOwner {
    require(_queueExpiry != 0, "QueueExpiry must be larger than 0");
    require(_queueExpiry != queueExpiry, "QueueExpiry unchanged");
    queueExpiry = _queueExpiry;
    emit QueueExpirySet(_queueExpiry);
  }

  /**
   * @notice Updates the minimum number of seconds before the next batch of proposals can be
   *   dequeued.
   * @param _dequeueFrequency The number of seconds before the next batch of proposals can be
   *   dequeued.
   */
  function setDequeueFrequency(uint256 _dequeueFrequency) public onlyOwner {
    require(_dequeueFrequency != 0, "dequeueFrequency must be larger than 0");
    require(_dequeueFrequency != dequeueFrequency, "dequeueFrequency unchanged");
    dequeueFrequency = _dequeueFrequency;
    emit DequeueFrequencySet(_dequeueFrequency);
  }

  /**
   * @notice Updates the number of seconds proposals stay in the referendum stage.
   * @param referendumStageDuration The number of seconds proposals stay in the referendum stage.
   */
  function setReferendumStageDuration(uint256 referendumStageDuration) public onlyOwner {
    require(referendumStageDuration != 0, "Duration must be larger than 0");
    require(referendumStageDuration != stageDurations.referendum, "Duration unchanged");
    stageDurations.referendum = referendumStageDuration;
    emit ReferendumStageDurationSet(referendumStageDuration);
  }

  /**
   * @notice Updates the number of seconds proposals stay in the execution stage.
   * @param executionStageDuration The number of seconds proposals stay in the execution stage.
   */
  function setExecutionStageDuration(uint256 executionStageDuration) public onlyOwner {
    require(executionStageDuration != 0, "Duration must be larger than 0");
    require(executionStageDuration != stageDurations.execution, "Duration unchanged");
    stageDurations.execution = executionStageDuration;
    emit ExecutionStageDurationSet(executionStageDuration);
  }

  /**
   * @notice Updates the participation baseline.
   * @param participationBaseline The value of the baseline.
   */
  function setParticipationBaseline(uint256 participationBaseline) public onlyOwner {
    FixidityLib.Fraction memory participationBaselineFrac = FixidityLib.wrap(participationBaseline);
    require(
      FixidityLib.isProperFraction(participationBaselineFrac),
      "Participation baseline greater than one"
    );
    require(
      !participationBaselineFrac.equals(participationParameters.baseline),
      "Participation baseline unchanged"
    );
    participationParameters.baseline = participationBaselineFrac;
    emit ParticipationBaselineUpdated(participationBaseline);
  }

  /**
   * @notice Updates the floor of the participation baseline.
   * @param participationFloor The value at which the baseline is floored.
   */
  function setParticipationFloor(uint256 participationFloor) public onlyOwner {
    FixidityLib.Fraction memory participationFloorFrac = FixidityLib.wrap(participationFloor);
    require(
      FixidityLib.isProperFraction(participationFloorFrac),
      "Participation floor greater than one"
    );
    require(
      !participationFloorFrac.equals(participationParameters.baselineFloor),
      "Participation baseline floor unchanged"
    );
    participationParameters.baselineFloor = participationFloorFrac;
    emit ParticipationFloorSet(participationFloor);
  }

  /**
   * @notice Updates the weight of the new participation in the baseline update rule.
   * @param baselineUpdateFactor The new baseline update factor.
   */
  function setBaselineUpdateFactor(uint256 baselineUpdateFactor) public onlyOwner {
    FixidityLib.Fraction memory baselineUpdateFactorFrac = FixidityLib.wrap(baselineUpdateFactor);
    require(
      FixidityLib.isProperFraction(baselineUpdateFactorFrac),
      "Baseline update factor greater than one"
    );
    require(
      !baselineUpdateFactorFrac.equals(participationParameters.baselineUpdateFactor),
      "Baseline update factor unchanged"
    );
    participationParameters.baselineUpdateFactor = baselineUpdateFactorFrac;
    emit ParticipationBaselineUpdateFactorSet(baselineUpdateFactor);
  }

  /**
   * @notice Updates the proportion of the baseline that constitutes quorum.
   * @param baselineQuorumFactor The new baseline quorum factor.
   */
  function setBaselineQuorumFactor(uint256 baselineQuorumFactor) public onlyOwner {
    FixidityLib.Fraction memory baselineQuorumFactorFrac = FixidityLib.wrap(baselineQuorumFactor);
    require(
      FixidityLib.isProperFraction(baselineQuorumFactorFrac),
      "Baseline quorum factor greater than one"
    );
    require(
      !baselineQuorumFactorFrac.equals(participationParameters.baselineQuorumFactor),
      "Baseline quorum factor unchanged"
    );
    participationParameters.baselineQuorumFactor = baselineQuorumFactorFrac;
    emit ParticipationBaselineQuorumFactorSet(baselineQuorumFactor);
  }

  /**
   * @notice Updates the ratio of yes:yes+no votes needed for a specific class of proposals to pass.
   * @param destination The destination of proposals for which this threshold should apply.
   * @param functionId The function ID of proposals for which this threshold should apply. Zero
   *   will set the default.
   * @param threshold The threshold.
   * @dev If no constitution is explicitly set the default is a simple majority, i.e. 1:2.
   */
  function setConstitution(address destination, bytes4 functionId, uint256 threshold)
    external
    onlyOwner
  {
    require(destination != address(0), "Destination cannot be zero");
    require(
      threshold > FIXED_HALF && threshold <= FixidityLib.fixed1().unwrap(),
      "Threshold has to be greater than majority and not greater than unanimity"
    );
    if (functionId == 0) {
      constitution[destination].defaultThreshold = FixidityLib.wrap(threshold);
    } else {
      constitution[destination].functionThresholds[functionId] = FixidityLib.wrap(threshold);
    }
    emit ConstitutionSet(destination, functionId, threshold);
  }

  /**
   * @notice Creates a new proposal and adds it to end of the queue with no upvotes.
   * @param values The values of CELO to be sent in the proposed transactions.
   * @param destinations The destination addresses of the proposed transactions.
   * @param data The concatenated data to be included in the proposed transactions.
   * @param dataLengths The lengths of each transaction's data.
   * @return The ID of the newly proposed proposal.
   * @dev The minimum deposit must be included with the proposal, returned if/when the proposal is
   *   dequeued.
   */
  function propose(
    uint256[] calldata values,
    address[] calldata destinations,
    bytes calldata data,
    uint256[] calldata dataLengths,
    string calldata descriptionUrl
  ) external payable returns (uint256) {
    dequeueProposalsIfReady();
    require(msg.value >= minDeposit, "Too small deposit");

    proposalCount = proposalCount.add(1);
    Proposals.Proposal storage proposal = proposals[proposalCount];
    proposal.make(values, destinations, data, dataLengths, msg.sender, msg.value);
    proposal.setDescriptionUrl(descriptionUrl);
    queue.push(proposalCount);
    // solhint-disable-next-line not-rely-on-time
    emit ProposalQueued(proposalCount, msg.sender, proposal.transactions.length, msg.value, now);
    return proposalCount;
  }

  /**
   * @notice Removes a proposal if it is queued and expired.
   * @param proposalId The ID of the proposal to remove.
   * @return Whether the proposal was removed.
   */
  function removeIfQueuedAndExpired(uint256 proposalId) private returns (bool) {
    if (isQueued(proposalId) && isQueuedProposalExpired(proposalId)) {
      queue.remove(proposalId);
      emit ProposalExpired(proposalId);
      return true;
    }
    return false;
  }

  /**
   * @notice Requires a proposal is dequeued and removes it if expired.
   * @param proposalId The ID of the proposal.
   * @return The proposal storage struct corresponding to `proposalId`.
   * @return The proposal stage corresponding to `proposalId`.
   */
  function requireDequeuedAndDeleteExpired(uint256 proposalId, uint256 index)
    private
    returns (Proposals.Proposal storage, Proposals.Stage)
  {
    Proposals.Proposal storage proposal = proposals[proposalId];
    require(_isDequeuedProposal(proposal, proposalId, index), "Proposal not dequeued");
    Proposals.Stage stage = getProposalDequeuedStage(proposal);
    if (_isDequeuedProposalExpired(proposal, stage)) {
      deleteDequeuedProposal(proposal, proposalId, index);
      return (proposal, Proposals.Stage.Expiration);
    }
    return (proposal, stage);
  }

  /**
   * @notice Upvotes a queued proposal.
   * @param proposalId The ID of the proposal to upvote.
   * @param lesser The ID of the proposal that will be just behind `proposalId` in the queue.
   * @param greater The ID of the proposal that will be just ahead `proposalId` in the queue.
   * @return Whether or not the upvote was made successfully.
   * @dev Provide 0 for `lesser`/`greater` when the proposal will be at the tail/head of the queue.
   * @dev Reverts if the account has already upvoted a proposal in the queue.
   */
  function upvote(uint256 proposalId, uint256 lesser, uint256 greater)
    external
    nonReentrant
    returns (bool)
  {
    dequeueProposalsIfReady();
    // If acting on an expired proposal, expire the proposal and take no action.
    if (removeIfQueuedAndExpired(proposalId)) {
      return false;
    }

    address account = getAccounts().voteSignerToAccount(msg.sender);
    Voter storage voter = voters[account];
    removeIfQueuedAndExpired(voter.upvote.proposalId);

    // We can upvote a proposal in the queue if we're not already upvoting a proposal in the queue.
    uint256 weight = getLockedGold().getAccountTotalLockedGold(account);
    require(weight > 0, "cannot upvote without locking gold");
    require(queue.contains(proposalId), "cannot upvote a proposal not in the queue");
    require(
      voter.upvote.proposalId == 0 || !queue.contains(voter.upvote.proposalId),
      "cannot upvote more than one queued proposal"
    );
    uint256 upvotes = queue.getValue(proposalId).add(weight);
    queue.update(proposalId, upvotes, lesser, greater);
    voter.upvote = UpvoteRecord(proposalId, weight);
    emit ProposalUpvoted(proposalId, account, weight);
    return true;
  }

  /**
   * @notice Returns stage of governance process given proposal is in
   * @param proposalId The ID of the proposal to query.
   * @return proposal stage
   */
  function getProposalStage(uint256 proposalId) external view returns (Proposals.Stage) {
    if (proposalId == 0 || proposalId > proposalCount) {
      return Proposals.Stage.None;
    }
    Proposals.Proposal storage proposal = proposals[proposalId];
    if (isQueued(proposalId)) {
      return
        _isQueuedProposalExpired(proposal) ? Proposals.Stage.Expiration : Proposals.Stage.Queued;
    } else {
      Proposals.Stage stage = getProposalDequeuedStage(proposal);
      return _isDequeuedProposalExpired(proposal, stage) ? Proposals.Stage.Expiration : stage;
    }
  }

  /**
   * @notice Revokes an upvote on a queued proposal.
   * @param lesser The ID of the proposal that will be just behind the previously upvoted proposal
   *   in the queue.
   * @param greater The ID of the proposal that will be just ahead of the previously upvoted
   *   proposal in the queue.
   * @return Whether or not the upvote was revoked successfully.
   * @dev Provide 0 for `lesser`/`greater` when the proposal will be at the tail/head of the queue.
   */
  function revokeUpvote(uint256 lesser, uint256 greater) external nonReentrant returns (bool) {
    dequeueProposalsIfReady();
    address account = getAccounts().voteSignerToAccount(msg.sender);
    Voter storage voter = voters[account];
    uint256 proposalId = voter.upvote.proposalId;
    require(proposalId != 0, "Account has no historical upvote");
    removeIfQueuedAndExpired(proposalId);
    if (queue.contains(proposalId)) {
      queue.update(
        proposalId,
        queue.getValue(proposalId).sub(voter.upvote.weight),
        lesser,
        greater
      );
      emit ProposalUpvoteRevoked(proposalId, account, voter.upvote.weight);
    }
    voter.upvote = UpvoteRecord(0, 0);
    return true;
  }

  /**
   * @notice Approves a proposal in the approval stage.
   * @param proposalId The ID of the proposal to approve.
   * @param index The index of the proposal ID in `dequeued`.
   * @return Whether or not the approval was made successfully.
   */
  function approve(uint256 proposalId, uint256 index) external onlyApprover returns (bool) {
    dequeueProposalsIfReady();
    (Proposals.Proposal storage proposal, Proposals.Stage stage) = requireDequeuedAndDeleteExpired(
      proposalId,
      index
    );
    if (!proposal.exists()) {
      return false;
    }

    require(!proposal.isApproved(), "Proposal already approved");
    require(
      stage == Proposals.Stage.Referendum || stage == Proposals.Stage.Execution,
      "Proposal not in correct stage"
    );
    proposal.approved = true;
    // Ensures networkWeight is set by the end of the Referendum stage, even if 0 votes are cast.
    proposal.networkWeight = getLockedGold().getTotalLockedGold();
    emit ProposalApproved(proposalId);
    return true;
  }

  /**
   * @notice Votes on a proposal in the referendum stage.
   * @param proposalId The ID of the proposal to vote on.
   * @param index The index of the proposal ID in `dequeued`.
   * @param value Whether to vote yes, no, or abstain.
   * @return Whether or not the vote was cast successfully.
   */
  /* solhint-disable code-complexity */
  function vote(uint256 proposalId, uint256 index, Proposals.VoteValue value)
    external
    nonReentrant
    returns (bool)
  {
    dequeueProposalsIfReady();
    (Proposals.Proposal storage proposal, Proposals.Stage stage) = requireDequeuedAndDeleteExpired(
      proposalId,
      index
    );
    if (!proposal.exists()) {
      return false;
    }

    require(stage == Proposals.Stage.Referendum, "Incorrect proposal state");
    require(value != Proposals.VoteValue.None, "Vote value unset");

    address account = getAccounts().voteSignerToAccount(msg.sender);
    uint256 weight = getLockedGold().getAccountTotalGovernanceVotingPower(account);
    require(weight != 0, "Voter weight zero");

    _vote(
      proposal,
      proposalId,
      index,
      account,
      value == Proposals.VoteValue.Yes ? weight : 0,
      value == Proposals.VoteValue.No ? weight : 0,
      value == Proposals.VoteValue.Abstain ? weight : 0
    );
    return true;
  }

  /**
   * @notice Votes partially on a proposal in the referendum stage.
   * @param proposalId The ID of the proposal to vote on.
   * @param index The index of the proposal ID in `dequeued`.
   * @param yesVotes The yes votes weight.
   * @param noVotes The no votes weight.
   * @param abstainVotes The abstain votes weight.
   * @return Whether or not the vote was cast successfully.
   */
  /* solhint-disable code-complexity */
  function votePartially(
    uint256 proposalId,
    uint256 index,
    uint256 yesVotes,
    uint256 noVotes,
    uint256 abstainVotes
  ) external nonReentrant returns (bool) {
    dequeueProposalsIfReady();
    (Proposals.Proposal storage proposal, Proposals.Stage stage) = requireDequeuedAndDeleteExpired(
      proposalId,
      index
    );
    if (!proposal.exists()) {
      return false;
    }

    require(stage == Proposals.Stage.Referendum, "Incorrect proposal state");

    address account = getAccounts().voteSignerToAccount(msg.sender);
    uint256 totalVotingPower = getLockedGold().getAccountTotalGovernanceVotingPower(account);

    require(
      totalVotingPower >= yesVotes.add(noVotes).add(abstainVotes),
      "Voter doesn't have enough locked Celo (formerly known as Celo Gold)"
    );
    _vote(proposal, proposalId, index, account, yesVotes, noVotes, abstainVotes);

    return true;
  }

  /**
   * @notice Votes on a proposal in the referendum stage.
   * @param proposal The proposal struct.
   * @param proposalId The ID of the proposal to vote on.
   * @param index The index of the proposal ID in `dequeued`.
   * @param account Account based on signer.
   * @param yesVotes The yes votes weight.
   * @param noVotes The no votes weight.
   * @param abstainVotes The abstain votes weight.
   * @return Whether or not the proposal is passing.
   */
  function _vote(
    Proposals.Proposal storage proposal,
    uint256 proposalId,
    uint256 index,
    address account,
    uint256 yesVotes,
    uint256 noVotes,
    uint256 abstainVotes
  ) private {
    Voter storage voter = voters[account];

    VoteRecord storage previousVoteRecord = voter.referendumVotes[index];

    if (previousVoteRecord.proposalId != proposalId) {
      // VoteRecord is being stored based on index (in `dequeued`) rather than proposalId.
      // It can happen that user voted on proposal that later gets deleted.
      // VoteRecord will still stay in `referendumVotes` mapping.
      // Once new proposal is created it might get same index as previous proposal.
      // In such case we need to check whether existing VoteRecord is relevant to new
      // proposal of whether it is just left over data.
      proposal.updateVote(0, 0, 0, yesVotes, noVotes, abstainVotes);
    } else if (previousVoteRecord.deprecated_weight != 0) {
      // backward compatibility for transition period - this should be deleted later on
      proposal.updateVote(
        previousVoteRecord.deprecated_value == Proposals.VoteValue.Yes
          ? previousVoteRecord.deprecated_weight
          : 0,
        previousVoteRecord.deprecated_value == Proposals.VoteValue.No
          ? previousVoteRecord.deprecated_weight
          : 0,
        previousVoteRecord.deprecated_value == Proposals.VoteValue.Abstain
          ? previousVoteRecord.deprecated_weight
          : 0,
        yesVotes,
        noVotes,
        abstainVotes
      );
    } else {
      proposal.updateVote(
        previousVoteRecord.yesVotes,
        previousVoteRecord.noVotes,
        previousVoteRecord.abstainVotes,
        yesVotes,
        noVotes,
        abstainVotes
      );
    }

    proposal.networkWeight = getLockedGold().getTotalLockedGold();
    voter.referendumVotes[index] = VoteRecord(
      Proposals.VoteValue.None,
      proposalId,
      0,
      yesVotes,
      noVotes,
      abstainVotes
    );
    if (proposal.timestamp > proposals[voter.mostRecentReferendumProposal].timestamp) {
      voter.mostRecentReferendumProposal = proposalId;
    }

    emit ProposalVotedV2(proposalId, account, yesVotes, noVotes, abstainVotes);
  }

  /* solhint-enable code-complexity */

  /**
   * @notice Revoke votes on all proposals of sender in the referendum stage.
   * @return Whether or not all votes of an account were successfully revoked.
   */
  function revokeVotes() external nonReentrant returns (bool) {
    address account = getAccounts().voteSignerToAccount(msg.sender);
    Voter storage voter = voters[account];
    for (
      uint256 dequeueIndex = 0;
      dequeueIndex < dequeued.length;
      dequeueIndex = dequeueIndex.add(1)
    ) {
      VoteRecord storage voteRecord = voter.referendumVotes[dequeueIndex];

      // Skip proposals where there was no vote cast by the user AND
      // ensure vote record proposal matches identifier of dequeued index proposal.
      if (
        voteRecord.proposalId == dequeued[dequeueIndex] &&
        (voteRecord.yesVotes != 0 ||
          voteRecord.noVotes != 0 ||
          voteRecord.abstainVotes != 0 ||
          voteRecord.deprecated_weight != 0)
      ) {
        (Proposals.Proposal storage proposal, Proposals.Stage stage) =
          requireDequeuedAndDeleteExpired(voteRecord.proposalId, dequeueIndex); // prettier-ignore

        // only revoke from proposals which are still in referendum
        if (stage == Proposals.Stage.Referendum) {
          if (voteRecord.deprecated_weight != 0) {
            // backward compatibility for transition period - this should be deleted later on
            uint256 previousYes = voteRecord.deprecated_value == Proposals.VoteValue.Yes
              ? voteRecord.deprecated_weight
              : 0;
            uint256 previousNo = voteRecord.deprecated_value == Proposals.VoteValue.No
              ? voteRecord.deprecated_weight
              : 0;
            uint256 previousAbstain = voteRecord.deprecated_value == Proposals.VoteValue.Abstain
              ? voteRecord.deprecated_weight
              : 0;
            proposal.updateVote(previousYes, previousNo, previousAbstain, 0, 0, 0);

            proposal.networkWeight = getLockedGold().getTotalLockedGold();
            emit ProposalVoteRevokedV2(
              voteRecord.proposalId,
              account,
              previousYes,
              previousNo,
              previousAbstain
            );
          } else {
            proposal.updateVote(
              voteRecord.yesVotes,
              voteRecord.noVotes,
              voteRecord.abstainVotes,
              0,
              0,
              0
            );
            proposal.networkWeight = getLockedGold().getTotalLockedGold();
            emit ProposalVoteRevokedV2(
              voteRecord.proposalId,
              account,
              voteRecord.yesVotes,
              voteRecord.noVotes,
              voteRecord.abstainVotes
            );
          }
        }

        // always delete dequeue vote records for gas refund as they must be expired or revoked
        delete voter.referendumVotes[dequeueIndex];
      }
    }

    // reset most recent referendum proposal ID to guarantee isVotingReferendum == false
    voter.mostRecentReferendumProposal = 0;
    return true;
  }

  /**
   * @notice Executes a proposal in the execution stage, removing it from `dequeued`.
   * @param proposalId The ID of the proposal to vote on.
   * @param index The index of the proposal ID in `dequeued`.
   * @return Whether or not the proposal was executed successfully.
   * @dev Does not remove the proposal if the execution fails.
   */
  function execute(uint256 proposalId, uint256 index) external nonReentrant returns (bool) {
    dequeueProposalsIfReady();
    (Proposals.Proposal storage proposal, Proposals.Stage stage) = requireDequeuedAndDeleteExpired(
      proposalId,
      index
    );
    bool notExpired = proposal.exists();
    if (notExpired) {
      require(proposal.isApproved(), "Proposal not approved");
      require(
        stage == Proposals.Stage.Execution && _isProposalPassing(proposal),
        "Proposal not in execution stage or not passing"
      );
      proposal.execute();
      emit ProposalExecuted(proposalId);
      deleteDequeuedProposal(proposal, proposalId, index);
    }
    return notExpired;
  }

  /**
   * @notice Approves the hash of a hotfix transaction(s).
   * @param hash The abi encoded keccak256 hash of the hotfix transaction(s) to be approved.
   */
  function approveHotfix(bytes32 hash) external hotfixNotExecuted(hash) onlyApprover {
    hotfixes[hash].approved = true;
    emit HotfixApproved(hash);
  }

  /**
   * @notice Returns whether given hotfix hash has been whitelisted by given address.
   * @param hash The abi encoded keccak256 hash of the hotfix transaction(s) to be whitelisted.
   * @param whitelister Address to check whitelist status of.
   */
  function isHotfixWhitelistedBy(bytes32 hash, address whitelister) public view returns (bool) {
    return hotfixes[hash].whitelisted[whitelister];
  }

  /**
   * @notice Whitelists the hash of a hotfix transaction(s).
   * @param hash The abi encoded keccak256 hash of the hotfix transaction(s) to be whitelisted.
   */
  function whitelistHotfix(bytes32 hash) external hotfixNotExecuted(hash) {
    hotfixes[hash].whitelisted[msg.sender] = true;
    emit HotfixWhitelisted(hash, msg.sender);
  }

  /**
   * @notice Gives hotfix a prepared epoch for execution.
   * @param hash The hash of the hotfix to be prepared.
   */
  function prepareHotfix(bytes32 hash) external hotfixNotExecuted(hash) {
    require(isHotfixPassing(hash), "hotfix not whitelisted by 2f+1 validators");
    uint256 epoch = getEpochNumber();
    require(hotfixes[hash].preparedEpoch < epoch, "hotfix already prepared for this epoch");
    hotfixes[hash].preparedEpoch = epoch;
    emit HotfixPrepared(hash, epoch);
  }

  /**
   * @notice Executes a whitelisted proposal.
   * @param values The values of CELO to be sent in the proposed transactions.
   * @param destinations The destination addresses of the proposed transactions.
   * @param data The concatenated data to be included in the proposed transactions.
   * @param dataLengths The lengths of each transaction's data.
   * @param salt Arbitrary salt associated with hotfix which guarantees uniqueness of hash.
   * @dev Reverts if hotfix is already executed, not approved, or not prepared for current epoch.
   */
  function executeHotfix(
    uint256[] calldata values,
    address[] calldata destinations,
    bytes calldata data,
    uint256[] calldata dataLengths,
    bytes32 salt
  ) external {
    bytes32 hash = keccak256(abi.encode(values, destinations, data, dataLengths, salt));

    (bool approved, bool executed, uint256 preparedEpoch) = getHotfixRecord(hash);
    require(!executed, "hotfix already executed");
    require(approved, "hotfix not approved");
    require(preparedEpoch == getEpochNumber(), "hotfix must be prepared for this epoch");

    Proposals.makeMem(values, destinations, data, dataLengths, msg.sender, 0).executeMem();

    hotfixes[hash].executed = true;
    emit HotfixExecuted(hash);
  }

  /**
   * @notice Withdraws refunded CELO deposits.
   * @return Whether or not the withdraw was successful.
   */
  function withdraw() external nonReentrant returns (bool) {
    uint256 value = refundedDeposits[msg.sender];
    require(value != 0, "Nothing to withdraw");
    require(value <= address(this).balance, "Inconsistent balance");
    refundedDeposits[msg.sender] = 0;
    msg.sender.sendValue(value);
    return true;
  }

  /**
   * @notice Returns whether or not a particular account is voting on proposals.
   * @param account The address of the account.
   * @return Whether or not the account is voting on proposals.
   */
  function isVoting(address account) external view returns (bool) {
    Voter storage voter = voters[account];
    uint256 upvotedProposal = voter.upvote.proposalId;
    bool isVotingQueue = upvotedProposal != 0 &&
      isQueued(upvotedProposal) &&
      !isQueuedProposalExpired(upvotedProposal);
    Proposals.Proposal storage proposal = proposals[voter.mostRecentReferendumProposal];
    bool isVotingReferendum = (getProposalDequeuedStage(proposal) == Proposals.Stage.Referendum);
    return isVotingQueue || isVotingReferendum;
  }

  /**
   * @notice Returns the number of seconds proposals stay in the referendum stage.
   * @return The number of seconds proposals stay in the referendum stage.
   */
  function getReferendumStageDuration() external view returns (uint256) {
    return stageDurations.referendum;
  }

  /**
   * @notice Returns the number of seconds proposals stay in the execution stage.
   * @return The number of seconds proposals stay in the execution stage.
   */
  function getExecutionStageDuration() external view returns (uint256) {
    return stageDurations.execution;
  }

  /**
   * @notice Returns the participation parameters.
   * @return baseline The participation baseline parameter.
   * @return baselineFloor The participation baseline floor parameter.
   * @return baselineUpdateFactor The participation baseline update factor parameter.
   * @return baselineQuorumFactor The participation baseline quorum factor parameter.
   */
  function getParticipationParameters() external view returns (uint256, uint256, uint256, uint256) {
    return (
      participationParameters.baseline.unwrap(),
      participationParameters.baselineFloor.unwrap(),
      participationParameters.baselineUpdateFactor.unwrap(),
      participationParameters.baselineQuorumFactor.unwrap()
    );
  }

  /**
   * @notice Returns whether or not a proposal exists.
   * @param proposalId The ID of the proposal.
   * @return Whether or not the proposal exists.
   */
  function proposalExists(uint256 proposalId) external view returns (bool) {
    return proposals[proposalId].exists();
  }

  /**
   * @notice Returns an unpacked proposal struct with its transaction count.
   * @param proposalId The ID of the proposal to unpack.
   * @return proposer
   * @return deposit
   * @return timestamp
   * @return transaction Transaction count.
   * @return description Description url.
   */
  function getProposal(uint256 proposalId)
    external
    view
    returns (address, uint256, uint256, uint256, string memory, uint256, bool)
  {
    return proposals[proposalId].unpack();
  }

  /**
   * @notice Returns a specified transaction in a proposal.
   * @param proposalId The ID of the proposal to query.
   * @param index The index of the specified transaction in the proposal's transaction list.
   * @return value Transaction value.
   * @return destination Transaction destination.
   * @return data Transaction data.
   */
  function getProposalTransaction(uint256 proposalId, uint256 index)
    external
    view
    returns (uint256, address, bytes memory)
  {
    return proposals[proposalId].getTransaction(index);
  }

  /**
   * @notice Returns whether or not a proposal has been approved.
   * @param proposalId The ID of the proposal.
   * @return Whether or not the proposal has been approved.
   */
  function isApproved(uint256 proposalId) external view returns (bool) {
    return proposals[proposalId].isApproved();
  }

  /**
   * @notice Returns the referendum vote totals for a proposal.
   * @param proposalId The ID of the proposal.
   * @return yes The yes vote totals.
   * @return no The no vote totals.
   * @return abstain The abstain vote totals.
   */
  function getVoteTotals(uint256 proposalId) external view returns (uint256, uint256, uint256) {
    return proposals[proposalId].getVoteTotals();
  }

  /**
   * @notice Returns an accounts vote record on a particular index in `dequeued`.
   * @param account The address of the account to get the record for.
   * @param index The index in `dequeued`.
   * @return The corresponding proposal ID, vote value, and weight.
   * @return The depreciated vote value.
   * @return The deprecieated weight.
   * @return The yes weight.
   * @return The no weight.
   * @return The abstain weight.
   */
  function getVoteRecord(address account, uint256 index)
    external
    view
    returns (uint256, uint256, uint256, uint256, uint256, uint256)
  {
    VoteRecord storage record = voters[account].referendumVotes[index];
    return (
      record.proposalId,
      uint256(record.deprecated_value),
      record.deprecated_weight,
      record.yesVotes,
      record.noVotes,
      record.abstainVotes
    );
  }

  /**
   * @notice Returns the number of proposals in the queue.
   * @return The number of proposals in the queue.
   */
  function getQueueLength() external view returns (uint256) {
    return queue.list.numElements;
  }

  /**
   * @notice Returns the number of upvotes the queued proposal has received.
   * @param proposalId The ID of the proposal.
   * @return The number of upvotes a queued proposal has received.
   */
  function getUpvotes(uint256 proposalId) external view returns (uint256) {
    require(isQueued(proposalId), "Proposal not queued");
    return queue.getValue(proposalId);
  }

  /**
   * @notice Returns the proposal ID and upvote total for all queued proposals.
   * @return proposalID The proposal ID for all queued proposals.
   * @return total The upvote total for all queued proposals.
   * @dev Note that this includes expired proposals that have yet to be removed from the queue.
   */
  function getQueue() external view returns (uint256[] memory, uint256[] memory) {
    return queue.getElements();
  }

  /**
   * @notice Returns the dequeued proposal IDs.
   * @return The dequeued proposal IDs.
   * @dev Note that this includes unused indices with proposalId == 0 from deleted proposals.
   */
  function getDequeue() external view returns (uint256[] memory) {
    return dequeued;
  }

  /**
   * @notice Returns the ID of the proposal upvoted by `account` and the weight of that upvote.
   * @param account The address of the account.
   * @return The ID of the proposal upvoted by `account`.
   * @return The weight of that upvote.
   */
  function getUpvoteRecord(address account) external view returns (uint256, uint256) {
    UpvoteRecord memory upvoteRecord = voters[account].upvote;
    return (upvoteRecord.proposalId, upvoteRecord.weight);
  }

  /**
   * @notice Returns the ID of the most recently dequeued proposal voted on by `account`.
   * @param account The address of the account.
   * @return The ID of the most recently dequeued proposal voted on by `account`..
   */
  function getMostRecentReferendumProposal(address account) external view returns (uint256) {
    return voters[account].mostRecentReferendumProposal;
  }

  /**
   * @notice Returns number of validators from current set which have whitelisted the given hotfix.
   * @param hash The abi encoded keccak256 hash of the hotfix transaction.
   * @return Whitelist tally
   */
  function hotfixWhitelistValidatorTally(bytes32 hash) public view returns (uint256) {
    uint256 tally = 0;
    uint256 n = numberValidatorsInCurrentSet();
    IAccounts accounts = getAccounts();
    for (uint256 i = 0; i < n; i = i.add(1)) {
      address validatorSigner = validatorSignerAddressFromCurrentSet(i);
      address validatorAccount = accounts.signerToAccount(validatorSigner);
      if (
        isHotfixWhitelistedBy(hash, validatorSigner) ||
        isHotfixWhitelistedBy(hash, validatorAccount)
      ) {
        tally = tally.add(1);
      }
    }
    return tally;
  }

  /**
   * @notice Checks if a byzantine quorum of validators has whitelisted the given hotfix.
   * @param hash The abi encoded keccak256 hash of the hotfix transaction.
   * @return Whether validator whitelist tally >= validator byzantine quorum
   */
  function isHotfixPassing(bytes32 hash) public view returns (bool) {
    return hotfixWhitelistValidatorTally(hash) >= minQuorumSizeInCurrentSet();
  }

  /**
   * @notice Gets information about a hotfix.
   * @param hash The abi encoded keccak256 hash of the hotfix transaction.
   * @return Hotfix approved.
   * @return Hotfix executed.
   * @return Hotfix preparedEpoch.
   */
  function getHotfixRecord(bytes32 hash) public view returns (bool, bool, uint256) {
    return (hotfixes[hash].approved, hotfixes[hash].executed, hotfixes[hash].preparedEpoch);
  }

  /**
   * @notice Removes the proposals with the most upvotes from the queue, moving them to the
   *   approval stage.
   * @dev If any of the top proposals have expired, they are deleted.
   */
  function dequeueProposalsIfReady() public {
    // solhint-disable-next-line not-rely-on-time
    if (now >= lastDequeue.add(dequeueFrequency)) {
      uint256 numProposalsToDequeue = Math.min(concurrentProposals, queue.list.numElements);
      uint256[] memory dequeuedIds = queue.popN(numProposalsToDequeue);

      bool wasAnyProposalDequeued = false;
      for (uint256 i = 0; i < numProposalsToDequeue; i = i.add(1)) {
        uint256 proposalId = dequeuedIds[i];
        Proposals.Proposal storage proposal = proposals[proposalId];
        if (_isQueuedProposalExpired(proposal)) {
          emit ProposalExpired(proposalId);
          continue;
        }
        refundedDeposits[proposal.proposer] = refundedDeposits[proposal.proposer].add(
          proposal.deposit
        );
        // solhint-disable-next-line not-rely-on-time
        proposal.timestamp = now;
        if (emptyIndices.length != 0) {
          uint256 indexOfLastEmptyIndex = emptyIndices.length.sub(1);
          dequeued[emptyIndices[indexOfLastEmptyIndex]] = proposalId;
          delete emptyIndices[indexOfLastEmptyIndex];
          emptyIndices.length = indexOfLastEmptyIndex;
        } else {
          dequeued.push(proposalId);
        }
        // solhint-disable-next-line not-rely-on-time
        emit ProposalDequeued(proposalId, now);
        wasAnyProposalDequeued = true;
      }
      if (wasAnyProposalDequeued) {
        // solhint-disable-next-line not-rely-on-time
        lastDequeue = now;
      }
    }
  }

  /**
   * @notice Returns whether or not a proposal is in the queue.
   * @dev NOTE: proposal may be expired
   * @param proposalId The ID of the proposal.
   * @return Whether or not the proposal is in the queue.
   */
  function isQueued(uint256 proposalId) public view returns (bool) {
    return queue.contains(proposalId);
  }

  /**
   * @notice Returns whether or not a particular proposal is passing according to the constitution
   *   and the participation levels.
   * @param proposalId The ID of the proposal.
   * @return Whether or not the proposal is passing.
   */
  function isProposalPassing(uint256 proposalId) external view returns (bool) {
    return _isProposalPassing(proposals[proposalId]);
  }

  /**
   * @notice Returns whether or not a particular proposal is passing according to the constitution
   *   and the participation levels.
   * @param proposal The proposal struct.
   * @return Whether or not the proposal is passing.
   */
  function _isProposalPassing(Proposals.Proposal storage proposal) private view returns (bool) {
    FixidityLib.Fraction memory support = proposal.getSupportWithQuorumPadding(
      participationParameters.baseline.multiply(participationParameters.baselineQuorumFactor)
    );

    if (proposal.transactions.length == 0) {
      // default treshold
      FixidityLib.Fraction memory threshold = _getConstitution(address(0), "");
      return support.gt(threshold);
    }

    for (uint256 i = 0; i < proposal.transactions.length; i = i.add(1)) {
      bytes4 functionId = ExtractFunctionSignature.extractFunctionSignature(
        proposal.transactions[i].data
      );
      FixidityLib.Fraction memory threshold = _getConstitution(
        proposal.transactions[i].destination,
        functionId
      );
      if (support.lte(threshold)) {
        return false;
      }
    }
    return true;
  }

  /**
   * @notice Returns whether a proposal is dequeued at the given index.
   * @param proposalId The ID of the proposal.
   * @param index The index of the proposal ID in `dequeued`.
   * @return Whether the proposal is in `dequeued`.
   */
  function isDequeuedProposal(uint256 proposalId, uint256 index) external view returns (bool) {
    return _isDequeuedProposal(proposals[proposalId], proposalId, index);
  }

  /**
   * @notice Returns whether a proposal is dequeued at the given index.
   * @param proposal The proposal struct.
   * @param proposalId The ID of the proposal.
   * @param index The index of the proposal ID in `dequeued`.
   * @return Whether the proposal is in `dequeued` at index.
   */
  function _isDequeuedProposal(
    Proposals.Proposal storage proposal,
    uint256 proposalId,
    uint256 index
  ) private view returns (bool) {
    require(index < dequeued.length, "Provided index greater than dequeue length.");
    return proposal.exists() && dequeued[index] == proposalId;
  }

  /**
   * @notice Returns whether or not a dequeued proposal has expired.
   * @param proposalId The ID of the proposal.
   * @return Whether or not the dequeued proposal has expired.
   */
  function isDequeuedProposalExpired(uint256 proposalId) external view returns (bool) {
    Proposals.Proposal storage proposal = proposals[proposalId];
    return _isDequeuedProposalExpired(proposal, getProposalDequeuedStage(proposal));
  }

  /**
   * @notice Returns whether or not a dequeued proposal has expired.
   * @param proposal The proposal struct.
   * @return Whether or not the dequeued proposal has expired.
   */
  function _isDequeuedProposalExpired(Proposals.Proposal storage proposal, Proposals.Stage stage)
    private
    view
    returns (bool)
  {
    // The proposal is considered expired under the following conditions:
    //   1. Past the referendum stage and not passing.
    //   2. Past the execution stage.
    return ((stage > Proposals.Stage.Execution) ||
      (stage > Proposals.Stage.Referendum && !_isProposalPassing(proposal)));
  }

  /**
   * @notice Returns whether or not a queued proposal has expired.
   * @param proposalId The ID of the proposal.
   * @return Whether or not the dequeued proposal has expired.
   */
  function isQueuedProposalExpired(uint256 proposalId) public view returns (bool) {
    return _isQueuedProposalExpired(proposals[proposalId]);
  }

  /**
   * @notice Returns whether or not a queued proposal has expired.
   * @param proposal The proposal struct.
   * @return Whether or not the dequeued proposal has expired.
   */
  function _isQueuedProposalExpired(Proposals.Proposal storage proposal)
    private
    view
    returns (bool)
  {
    // solhint-disable-next-line not-rely-on-time
    return now >= proposal.timestamp.add(queueExpiry);
  }

  /**
   * @notice Deletes a dequeued proposal.
   * @param proposal The proposal struct.
   * @param proposalId The ID of the proposal to delete.
   * @param index The index of the proposal ID in `dequeued`.
   * @dev Must always be preceded by `isDequeuedProposal`, which checks `index`.
   */
  function deleteDequeuedProposal(
    Proposals.Proposal storage proposal,
    uint256 proposalId,
    uint256 index
  ) private {
    if (proposal.isApproved() && proposal.networkWeight != 0) {
      updateParticipationBaseline(proposal);
    }
    dequeued[index] = 0;
    emptyIndices.push(index);
    delete proposals[proposalId];
  }

  /**
   * @notice Updates the participation baseline based on the proportion of BondedDeposit weight
   *   that participated in the proposal's Referendum stage.
   * @param proposal The proposal struct.
   */
  function updateParticipationBaseline(Proposals.Proposal storage proposal) private {
    FixidityLib.Fraction memory participation = proposal.getParticipation();
    FixidityLib.Fraction memory participationComponent = participation.multiply(
      participationParameters.baselineUpdateFactor
    );
    FixidityLib.Fraction memory baselineComponent = participationParameters.baseline.multiply(
      FixidityLib.fixed1().subtract(participationParameters.baselineUpdateFactor)
    );
    participationParameters.baseline = participationComponent.add(baselineComponent);
    if (participationParameters.baseline.lt(participationParameters.baselineFloor)) {
      participationParameters.baseline = participationParameters.baselineFloor;
    }
    emit ParticipationBaselineUpdated(participationParameters.baseline.unwrap());
  }

  /**
   * @notice Returns the constitution for a particular destination and function ID.
   * @param destination The destination address to get the constitution for.
   * @param functionId The function ID to get the constitution for, zero for the destination
   *   default.
   * @return The ratio of yes:no votes needed to exceed in order to pass the proposal.
   */
  function getConstitution(address destination, bytes4 functionId) external view returns (uint256) {
    return _getConstitution(destination, functionId).unwrap();
  }

  function _getConstitution(address destination, bytes4 functionId)
    internal
    view
    returns (FixidityLib.Fraction memory)
  {
    // Default to a simple majority.
    FixidityLib.Fraction memory threshold = FixidityLib.wrap(FIXED_HALF);
    if (constitution[destination].functionThresholds[functionId].unwrap() != 0) {
      threshold = constitution[destination].functionThresholds[functionId];
    } else if (constitution[destination].defaultThreshold.unwrap() != 0) {
      threshold = constitution[destination].defaultThreshold;
    }
    return threshold;
  }

  /**
   * @notice Returns max number of votes cast by an account.
   * @param account The address of the account.
   * @return The total number of votes cast by an account.
   */
  function getAmountOfGoldUsedForVoting(address account) public view returns (uint256) {
    Voter storage voter = voters[account];

    uint256 upvotedProposalId = voter.upvote.proposalId;
    bool isVotingQueue = upvotedProposalId != 0 &&
      isQueued(upvotedProposalId) &&
      !isQueuedProposalExpired(upvotedProposalId);

    if (isVotingQueue) {
      uint256 weight = getLockedGold().getAccountTotalLockedGold(account);
      return weight;
    }

    uint256 maxUsed = 0;
    for (uint256 index = 0; index < dequeued.length; index = index.add(1)) {
      uint256 proposalId = dequeued[index];
      Proposals.Proposal storage proposal = proposals[proposalId];
      bool isVotingReferendum = (getProposalDequeuedStage(proposal) == Proposals.Stage.Referendum);

      if (!isVotingReferendum) {
        continue;
      }

      VoteRecord storage voteRecord = voter.referendumVotes[index];
      // skip if vote record is not for this proposal
      if (voteRecord.proposalId != proposalId) {
        continue;
      }

      uint256 votesCast = voteRecord.yesVotes.add(voteRecord.noVotes).add(voteRecord.abstainVotes);
      maxUsed = Math.max(
        maxUsed,
        // backward compatibility for transition period - this should be updated later on
        votesCast == 0 ? voteRecord.deprecated_weight : votesCast
      );
    }
    return maxUsed;
  }

  /**
   * @notice When delegator removes votes from delegatee during the time when delegator is voting
   * for governance proposal, this method will remove votes from voted proposal proportionally.
   * @param account The address of the account.
   * @param newVotingPower The adjusted voting power of delegatee.
   */
  function removeVotesWhenRevokingDelegatedVotes(address account, uint256 newVotingPower)
    public
    onlyLockedGold
  {
    _removeVotesWhenRevokingDelegatedVotes(account, newVotingPower);
  }

  /**
   * @notice When delegator removes votes from delegatee during the time when delegator is voting
   * for governance proposal, this method will remove votes from voted proposal proportionally.
   * @param account The address of the account.
   * @param newVotingPower The adjusted voting power of delegatee.
   */
  function _removeVotesWhenRevokingDelegatedVotes(address account, uint256 newVotingPower)
    internal
  {
    Voter storage voter = voters[account];

    for (uint256 index = 0; index < dequeued.length; index = index.add(1)) {
      uint256 proposalId = dequeued[index];
      Proposals.Proposal storage proposal = proposals[proposalId];
      bool isVotingReferendum = (getProposalDequeuedStage(proposal) == Proposals.Stage.Referendum);

      if (!isVotingReferendum) {
        continue;
      }

      VoteRecord storage voteRecord = voter.referendumVotes[index];

      // skip if vote record is not for this proposal
      if (voteRecord.proposalId != proposalId) {
        delete voter.referendumVotes[index];
        continue;
      }

      uint256 sumOfVotes = voteRecord.yesVotes.add(voteRecord.noVotes).add(voteRecord.abstainVotes);

      if (sumOfVotes > newVotingPower) {
        uint256 toRemove = sumOfVotes.sub(newVotingPower);

        uint256 abstainToRemove = getVotesPortion(toRemove, voteRecord.abstainVotes, sumOfVotes);
        uint256 yesToRemove = getVotesPortion(toRemove, voteRecord.yesVotes, sumOfVotes);
        uint256 noToRemove = getVotesPortion(toRemove, voteRecord.noVotes, sumOfVotes);

        uint256 totalRemoved = abstainToRemove.add(yesToRemove).add(noToRemove);

        uint256 yesVotes = voteRecord.yesVotes.sub(yesToRemove);
        uint256 noVotes = voteRecord.noVotes.sub(noToRemove);
        uint256 abstainVotes = voteRecord.abstainVotes.sub(abstainToRemove);

        if (totalRemoved < toRemove) {
          // in case of rounding error
          uint256 roundingToRemove = toRemove.sub(totalRemoved);

          uint256 toRemoveRounding = Math.min(roundingToRemove, yesVotes);
          yesVotes = yesVotes.sub(toRemoveRounding);
          roundingToRemove = roundingToRemove.sub(toRemoveRounding);

          if (roundingToRemove != 0) {
            toRemoveRounding = Math.min(roundingToRemove, noVotes);
            noVotes = noVotes.sub(toRemoveRounding);
            roundingToRemove = roundingToRemove.sub(toRemoveRounding);
          }

          if (roundingToRemove != 0) {
            toRemoveRounding = Math.min(roundingToRemove, abstainVotes);
            abstainVotes = abstainVotes.sub(toRemoveRounding);
          }
        }

        proposal.updateVote(
          voteRecord.yesVotes,
          voteRecord.noVotes,
          voteRecord.abstainVotes,
          yesVotes,
          noVotes,
          abstainVotes
        );

        voteRecord.abstainVotes = abstainVotes;
        voteRecord.yesVotes = yesVotes;
        voteRecord.noVotes = noVotes;
      }
    }
  }

  /**
   * Returns amount of votes that should be removed from delegatee's proposal voting.
   * @param totalToRemove Total votes to be removed.
   * @param votes Yes/no/abstrain votes
   * @param sumOfAllVotes Sum of yes, no, and abstain votes.
   */
  function getVotesPortion(uint256 totalToRemove, uint256 votes, uint256 sumOfAllVotes)
    private
    pure
    returns (uint256)
  {
    return
      FixidityLib
        .newFixed(totalToRemove)
        .multiply(FixidityLib.newFixedFraction(votes, sumOfAllVotes))
        .fromFixed();
  }

  /**
   * @param values The values of CELO to be sent in the proposed transactions.
   * @param destinations The destination addresses of the proposed transactions.
   * @param data The concatenated data to be included in the proposed transactions.
   * @param dataLengths The lengths of each transaction's data.
   * @param salt Arbitrary salt associated with hotfix which guarantees uniqueness of hash.
   * @return The hash of the hotfix.
   */
  function getHotfixHash(
    uint256[] calldata values,
    address[] calldata destinations,
    bytes calldata data,
    uint256[] calldata dataLengths,
    bytes32 salt
  ) external pure returns (bytes32) {
    return keccak256(abi.encode(values, destinations, data, dataLengths, salt));
  }

  /**
   * @notice Returns the stage of a dequeued proposal.
   * @param proposal The proposal struct.
   * @return The stage of the dequeued proposal.
   * @dev Must be called on a dequeued proposal.
   */
  function getProposalDequeuedStage(Proposals.Proposal storage proposal)
    internal
    view
    returns (Proposals.Stage)
  {
    uint256 stageStartTime = proposal.timestamp.add(stageDurations.referendum).add(
      stageDurations.execution
    );
    // solhint-disable-next-line not-rely-on-time
    if (
      now >= stageStartTime &&
      (proposal.transactions.length != 0 ||
        // proposals with 0 transactions can expire only when not approved or not passing
        !proposal.isApproved() ||
        !_isProposalPassing(proposal))
    ) {
      return Proposals.Stage.Expiration;
    }
    stageStartTime = stageStartTime.sub(stageDurations.execution);
    // solhint-disable-next-line not-rely-on-time
    if (now >= stageStartTime) {
      return Proposals.Stage.Execution;
    }
    return Proposals.Stage.Referendum;
  }
}
        

/openzeppelin-solidity/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;
    }
}
          

/openzeppelin-solidity/contracts/math/Math.sol

pragma solidity ^0.5.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}
          

/openzeppelin-solidity/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;
    }
}
          

/openzeppelin-solidity/contracts/ownership/Ownable.sol

pragma solidity ^0.5.0;

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

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(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;
    }
}
          

/openzeppelin-solidity/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

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

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

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

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

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

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

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

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

/openzeppelin-solidity/contracts/utils/Address.sol

pragma solidity ^0.5.5;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following 
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

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

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

/project:/contracts/common/ExtractFunctionSignature.sol

pragma solidity ^0.5.13;

library ExtractFunctionSignature {
  /**
   * @notice Extracts the first four bytes of a byte array.
   * @param input The byte array.
   * @return The first four bytes of `input`.
   */
  function extractFunctionSignature(bytes memory input) internal pure returns (bytes4) {
    return (bytes4(input[0]) |
      (bytes4(input[1]) >> 8) |
      (bytes4(input[2]) >> 16) |
      (bytes4(input[3]) >> 24));
  }
}
          

/project:/contracts/common/FixidityLib.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

/**
 * @title FixidityLib
 * @author Gadi Guy, Alberto Cuesta Canada
 * @notice This library provides fixed point arithmetic with protection against
 * overflow.
 * All operations are done with uint256 and the operands must have been created
 * with any of the newFrom* functions, which shift the comma digits() to the
 * right and check for limits, or with wrap() which expects a number already
 * in the internal representation of a fraction.
 * When using this library be sure to use maxNewFixed() as the upper limit for
 * creation of fixed point numbers.
 * @dev All contained functions are pure and thus marked internal to be inlined
 * on consuming contracts at compile time for gas efficiency.
 */
library FixidityLib {
  struct Fraction {
    uint256 value;
  }

  /**
   * @notice Number of positions that the comma is shifted to the right.
   */
  function digits() internal pure returns (uint8) {
    return 24;
  }

  uint256 private constant FIXED1_UINT = 1000000000000000000000000;

  /**
   * @notice This is 1 in the fixed point units used in this library.
   * @dev Test fixed1() equals 10^digits()
   * Hardcoded to 24 digits.
   */
  function fixed1() internal pure returns (Fraction memory) {
    return Fraction(FIXED1_UINT);
  }

  /**
   * @notice Wrap a uint256 that represents a 24-decimal fraction in a Fraction
   * struct.
   * @param x Number that already represents a 24-decimal fraction.
   * @return A Fraction struct with contents x.
   */
  function wrap(uint256 x) internal pure returns (Fraction memory) {
    return Fraction(x);
  }

  /**
   * @notice Unwraps the uint256 inside of a Fraction struct.
   */
  function unwrap(Fraction memory x) internal pure returns (uint256) {
    return x.value;
  }

  /**
   * @notice The amount of decimals lost on each multiplication operand.
   * @dev Test mulPrecision() equals sqrt(fixed1)
   */
  function mulPrecision() internal pure returns (uint256) {
    return 1000000000000;
  }

  /**
   * @notice Maximum value that can be converted to fixed point. Optimize for deployment.
   * @dev
   * Test maxNewFixed() equals maxUint256() / fixed1()
   */
  function maxNewFixed() internal pure returns (uint256) {
    return 115792089237316195423570985008687907853269984665640564;
  }

  /**
   * @notice Converts a uint256 to fixed point Fraction
   * @dev Test newFixed(0) returns 0
   * Test newFixed(1) returns fixed1()
   * Test newFixed(maxNewFixed()) returns maxNewFixed() * fixed1()
   * Test newFixed(maxNewFixed()+1) fails
   */
  function newFixed(uint256 x) internal pure returns (Fraction memory) {
    require(x <= maxNewFixed(), "can't create fixidity number larger than maxNewFixed()");
    return Fraction(x * FIXED1_UINT);
  }

  /**
   * @notice Converts a uint256 in the fixed point representation of this
   * library to a non decimal. All decimal digits will be truncated.
   */
  function fromFixed(Fraction memory x) internal pure returns (uint256) {
    return x.value / FIXED1_UINT;
  }

  /**
   * @notice Converts two uint256 representing a fraction to fixed point units,
   * equivalent to multiplying dividend and divisor by 10^digits().
   * @param numerator numerator must be <= maxNewFixed()
   * @param denominator denominator must be <= maxNewFixed() and denominator can't be 0
   * @dev
   * Test newFixedFraction(1,0) fails
   * Test newFixedFraction(0,1) returns 0
   * Test newFixedFraction(1,1) returns fixed1()
   * Test newFixedFraction(1,fixed1()) returns 1
   */
  function newFixedFraction(uint256 numerator, uint256 denominator)
    internal
    pure
    returns (Fraction memory)
  {
    Fraction memory convertedNumerator = newFixed(numerator);
    Fraction memory convertedDenominator = newFixed(denominator);
    return divide(convertedNumerator, convertedDenominator);
  }

  /**
   * @notice Returns the integer part of a fixed point number.
   * @dev
   * Test integer(0) returns 0
   * Test integer(fixed1()) returns fixed1()
   * Test integer(newFixed(maxNewFixed())) returns maxNewFixed()*fixed1()
   */
  function integer(Fraction memory x) internal pure returns (Fraction memory) {
    return Fraction((x.value / FIXED1_UINT) * FIXED1_UINT); // Can't overflow
  }

  /**
   * @notice Returns the fractional part of a fixed point number.
   * In the case of a negative number the fractional is also negative.
   * @dev
   * Test fractional(0) returns 0
   * Test fractional(fixed1()) returns 0
   * Test fractional(fixed1()-1) returns 10^24-1
   */
  function fractional(Fraction memory x) internal pure returns (Fraction memory) {
    return Fraction(x.value - (x.value / FIXED1_UINT) * FIXED1_UINT); // Can't overflow
  }

  /**
   * @notice x+y.
   * @dev The maximum value that can be safely used as an addition operator is defined as
   * maxFixedAdd = maxUint256()-1 / 2, or
   * 57896044618658097711785492504343953926634992332820282019728792003956564819967.
   * Test add(maxFixedAdd,maxFixedAdd) equals maxFixedAdd + maxFixedAdd
   * Test add(maxFixedAdd+1,maxFixedAdd+1) throws
   */
  function add(Fraction memory x, Fraction memory y) internal pure returns (Fraction memory) {
    uint256 z = x.value + y.value;
    require(z >= x.value, "add overflow detected");
    return Fraction(z);
  }

  /**
   * @notice x-y.
   * @dev
   * Test subtract(6, 10) fails
   */
  function subtract(Fraction memory x, Fraction memory y) internal pure returns (Fraction memory) {
    require(x.value >= y.value, "substraction underflow detected");
    return Fraction(x.value - y.value);
  }

  /**
   * @notice x*y. If any of the operators is higher than the max multiplier value it
   * might overflow.
   * @dev The maximum value that can be safely used as a multiplication operator
   * (maxFixedMul) is calculated as sqrt(maxUint256()*fixed1()),
   * or 340282366920938463463374607431768211455999999999999
   * Test multiply(0,0) returns 0
   * Test multiply(maxFixedMul,0) returns 0
   * Test multiply(0,maxFixedMul) returns 0
   * Test multiply(fixed1()/mulPrecision(),fixed1()*mulPrecision()) returns fixed1()
   * Test multiply(maxFixedMul,maxFixedMul) is around maxUint256()
   * Test multiply(maxFixedMul+1,maxFixedMul+1) fails
   */
  function multiply(Fraction memory x, Fraction memory y) internal pure returns (Fraction memory) {
    if (x.value == 0 || y.value == 0) return Fraction(0);
    if (y.value == FIXED1_UINT) return x;
    if (x.value == FIXED1_UINT) return y;

    // Separate into integer and fractional parts
    // x = x1 + x2, y = y1 + y2
    uint256 x1 = integer(x).value / FIXED1_UINT;
    uint256 x2 = fractional(x).value;
    uint256 y1 = integer(y).value / FIXED1_UINT;
    uint256 y2 = fractional(y).value;

    // (x1 + x2) * (y1 + y2) = (x1 * y1) + (x1 * y2) + (x2 * y1) + (x2 * y2)
    uint256 x1y1 = x1 * y1;
    if (x1 != 0) require(x1y1 / x1 == y1, "overflow x1y1 detected");

    // x1y1 needs to be multiplied back by fixed1
    // solium-disable-next-line mixedcase
    uint256 fixed_x1y1 = x1y1 * FIXED1_UINT;
    if (x1y1 != 0) require(fixed_x1y1 / x1y1 == FIXED1_UINT, "overflow x1y1 * fixed1 detected");
    x1y1 = fixed_x1y1;

    uint256 x2y1 = x2 * y1;
    if (x2 != 0) require(x2y1 / x2 == y1, "overflow x2y1 detected");

    uint256 x1y2 = x1 * y2;
    if (x1 != 0) require(x1y2 / x1 == y2, "overflow x1y2 detected");

    x2 = x2 / mulPrecision();
    y2 = y2 / mulPrecision();
    uint256 x2y2 = x2 * y2;
    if (x2 != 0) require(x2y2 / x2 == y2, "overflow x2y2 detected");

    // result = fixed1() * x1 * y1 + x1 * y2 + x2 * y1 + x2 * y2 / fixed1();
    Fraction memory result = Fraction(x1y1);
    result = add(result, Fraction(x2y1)); // Add checks for overflow
    result = add(result, Fraction(x1y2)); // Add checks for overflow
    result = add(result, Fraction(x2y2)); // Add checks for overflow
    return result;
  }

  /**
   * @notice 1/x
   * @dev
   * Test reciprocal(0) fails
   * Test reciprocal(fixed1()) returns fixed1()
   * Test reciprocal(fixed1()*fixed1()) returns 1 // Testing how the fractional is truncated
   * Test reciprocal(1+fixed1()*fixed1()) returns 0 // Testing how the fractional is truncated
   * Test reciprocal(newFixedFraction(1, 1e24)) returns newFixed(1e24)
   */
  function reciprocal(Fraction memory x) internal pure returns (Fraction memory) {
    require(x.value != 0, "can't call reciprocal(0)");
    return Fraction((FIXED1_UINT * FIXED1_UINT) / x.value); // Can't overflow
  }

  /**
   * @notice x/y. If the dividend is higher than the max dividend value, it
   * might overflow. You can use multiply(x,reciprocal(y)) instead.
   * @dev The maximum value that can be safely used as a dividend (maxNewFixed) is defined as
   * divide(maxNewFixed,newFixedFraction(1,fixed1())) is around maxUint256().
   * This yields the value 115792089237316195423570985008687907853269984665640564.
   * Test maxNewFixed equals maxUint256()/fixed1()
   * Test divide(maxNewFixed,1) equals maxNewFixed*(fixed1)
   * Test divide(maxNewFixed+1,multiply(mulPrecision(),mulPrecision())) throws
   * Test divide(fixed1(),0) fails
   * Test divide(maxNewFixed,1) = maxNewFixed*(10^digits())
   * Test divide(maxNewFixed+1,1) throws
   */
  function divide(Fraction memory x, Fraction memory y) internal pure returns (Fraction memory) {
    require(y.value != 0, "can't divide by 0");
    uint256 X = x.value * FIXED1_UINT;
    require(X / FIXED1_UINT == x.value, "overflow at divide");
    return Fraction(X / y.value);
  }

  /**
   * @notice x > y
   */
  function gt(Fraction memory x, Fraction memory y) internal pure returns (bool) {
    return x.value > y.value;
  }

  /**
   * @notice x >= y
   */
  function gte(Fraction memory x, Fraction memory y) internal pure returns (bool) {
    return x.value >= y.value;
  }

  /**
   * @notice x < y
   */
  function lt(Fraction memory x, Fraction memory y) internal pure returns (bool) {
    return x.value < y.value;
  }

  /**
   * @notice x <= y
   */
  function lte(Fraction memory x, Fraction memory y) internal pure returns (bool) {
    return x.value <= y.value;
  }

  /**
   * @notice x == y
   */
  function equals(Fraction memory x, Fraction memory y) internal pure returns (bool) {
    return x.value == y.value;
  }

  /**
   * @notice x <= 1
   */
  function isProperFraction(Fraction memory x) internal pure returns (bool) {
    return lte(x, fixed1());
  }
}
          

/project:/contracts/common/Initializable.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

contract Initializable {
  bool public initialized;

  constructor(bool testingDeployment) public {
    if (!testingDeployment) {
      initialized = true;
    }
  }

  modifier initializer() {
    require(!initialized, "contract already initialized");
    initialized = true;
    _;
  }
}
          

/project:/contracts/common/UsingPrecompiles.sol

pragma solidity ^0.5.13;

import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "../common/interfaces/ICeloVersionedContract.sol";

contract UsingPrecompiles {
  using SafeMath for uint256;

  address constant TRANSFER = address(0xff - 2);
  address constant FRACTION_MUL = address(0xff - 3);
  address constant PROOF_OF_POSSESSION = address(0xff - 4);
  address constant GET_VALIDATOR = address(0xff - 5);
  address constant NUMBER_VALIDATORS = address(0xff - 6);
  address constant EPOCH_SIZE = address(0xff - 7);
  address constant BLOCK_NUMBER_FROM_HEADER = address(0xff - 8);
  address constant HASH_HEADER = address(0xff - 9);
  address constant GET_PARENT_SEAL_BITMAP = address(0xff - 10);
  address constant GET_VERIFIED_SEAL_BITMAP = address(0xff - 11);

  /**
   * @notice calculate a * b^x for fractions a, b to `decimals` precision
   * @param aNumerator Numerator of first fraction
   * @param aDenominator Denominator of first fraction
   * @param bNumerator Numerator of exponentiated fraction
   * @param bDenominator Denominator of exponentiated fraction
   * @param exponent exponent to raise b to
   * @param _decimals precision
   * @return Numerator of the computed quantity (not reduced).
   * @return Denominator of the computed quantity (not reduced).
   */
  function fractionMulExp(
    uint256 aNumerator,
    uint256 aDenominator,
    uint256 bNumerator,
    uint256 bDenominator,
    uint256 exponent,
    uint256 _decimals
  ) public view returns (uint256, uint256) {
    require(aDenominator != 0 && bDenominator != 0, "a denominator is zero");
    uint256 returnNumerator;
    uint256 returnDenominator;
    bool success;
    bytes memory out;
    (success, out) = FRACTION_MUL.staticcall(
      abi.encodePacked(aNumerator, aDenominator, bNumerator, bDenominator, exponent, _decimals)
    );
    require(success, "error calling fractionMulExp precompile");
    returnNumerator = getUint256FromBytes(out, 0);
    returnDenominator = getUint256FromBytes(out, 32);
    return (returnNumerator, returnDenominator);
  }

  /**
   * @notice Returns the current epoch size in blocks.
   * @return The current epoch size in blocks.
   */
  function getEpochSize() public view returns (uint256) {
    bytes memory out;
    bool success;
    (success, out) = EPOCH_SIZE.staticcall(abi.encodePacked());
    require(success, "error calling getEpochSize precompile");
    return getUint256FromBytes(out, 0);
  }

  /**
   * @notice Returns the epoch number at a block.
   * @param blockNumber Block number where epoch number is calculated.
   * @return Epoch number.
   */
  function getEpochNumberOfBlock(uint256 blockNumber) public view returns (uint256) {
    return epochNumberOfBlock(blockNumber, getEpochSize());
  }

  /**
   * @notice Returns the epoch number at a block.
   * @return Current epoch number.
   */
  function getEpochNumber() public view returns (uint256) {
    return getEpochNumberOfBlock(block.number);
  }

  /**
   * @notice Returns the epoch number at a block.
   * @param blockNumber Block number where epoch number is calculated.
   * @param epochSize The epoch size in blocks.
   * @return Epoch number.
   */
  function epochNumberOfBlock(uint256 blockNumber, uint256 epochSize)
    internal
    pure
    returns (uint256)
  {
    // Follows GetEpochNumber from celo-blockchain/blob/master/consensus/istanbul/utils.go
    uint256 epochNumber = blockNumber / epochSize;
    if (blockNumber % epochSize == 0) {
      return epochNumber;
    } else {
      return epochNumber.add(1);
    }
  }

  /**
   * @notice Gets a validator address from the current validator set.
   * @param index Index of requested validator in the validator set.
   * @return Address of validator at the requested index.
   */
  function validatorSignerAddressFromCurrentSet(uint256 index) public view returns (address) {
    bytes memory out;
    bool success;
    (success, out) = GET_VALIDATOR.staticcall(abi.encodePacked(index, uint256(block.number)));
    require(success, "error calling validatorSignerAddressFromCurrentSet precompile");
    return address(getUint256FromBytes(out, 0));
  }

  /**
   * @notice Gets a validator address from the validator set at the given block number.
   * @param index Index of requested validator in the validator set.
   * @param blockNumber Block number to retrieve the validator set from.
   * @return Address of validator at the requested index.
   */
  function validatorSignerAddressFromSet(uint256 index, uint256 blockNumber)
    public
    view
    returns (address)
  {
    bytes memory out;
    bool success;
    (success, out) = GET_VALIDATOR.staticcall(abi.encodePacked(index, blockNumber));
    require(success, "error calling validatorSignerAddressFromSet precompile");
    return address(getUint256FromBytes(out, 0));
  }

  /**
   * @notice Gets the size of the current elected validator set.
   * @return Size of the current elected validator set.
   */
  function numberValidatorsInCurrentSet() public view returns (uint256) {
    bytes memory out;
    bool success;
    (success, out) = NUMBER_VALIDATORS.staticcall(abi.encodePacked(uint256(block.number)));
    require(success, "error calling numberValidatorsInCurrentSet precompile");
    return getUint256FromBytes(out, 0);
  }

  /**
   * @notice Gets the size of the validator set that must sign the given block number.
   * @param blockNumber Block number to retrieve the validator set from.
   * @return Size of the validator set.
   */
  function numberValidatorsInSet(uint256 blockNumber) public view returns (uint256) {
    bytes memory out;
    bool success;
    (success, out) = NUMBER_VALIDATORS.staticcall(abi.encodePacked(blockNumber));
    require(success, "error calling numberValidatorsInSet precompile");
    return getUint256FromBytes(out, 0);
  }

  /**
   * @notice Checks a BLS proof of possession.
   * @param sender The address signed by the BLS key to generate the proof of possession.
   * @param blsKey The BLS public key that the validator is using for consensus, should pass proof
   *   of possession. 48 bytes.
   * @param blsPop The BLS public key proof-of-possession, which consists of a signature on the
   *   account address. 96 bytes.
   * @return True upon success.
   */
  function checkProofOfPossession(address sender, bytes memory blsKey, bytes memory blsPop)
    public
    view
    returns (bool)
  {
    bool success;
    (success, ) = PROOF_OF_POSSESSION.staticcall(abi.encodePacked(sender, blsKey, blsPop));
    return success;
  }

  /**
   * @notice Parses block number out of header.
   * @param header RLP encoded header
   * @return Block number.
   */
  function getBlockNumberFromHeader(bytes memory header) public view returns (uint256) {
    bytes memory out;
    bool success;
    (success, out) = BLOCK_NUMBER_FROM_HEADER.staticcall(abi.encodePacked(header));
    require(success, "error calling getBlockNumberFromHeader precompile");
    return getUint256FromBytes(out, 0);
  }

  /**
   * @notice Computes hash of header.
   * @param header RLP encoded header
   * @return Header hash.
   */
  function hashHeader(bytes memory header) public view returns (bytes32) {
    bytes memory out;
    bool success;
    (success, out) = HASH_HEADER.staticcall(abi.encodePacked(header));
    require(success, "error calling hashHeader precompile");
    return getBytes32FromBytes(out, 0);
  }

  /**
   * @notice Gets the parent seal bitmap from the header at the given block number.
   * @param blockNumber Block number to retrieve. Must be within 4 epochs of the current number.
   * @return Bitmap parent seal with set bits at indices corresponding to signing validators.
   */
  function getParentSealBitmap(uint256 blockNumber) public view returns (bytes32) {
    bytes memory out;
    bool success;
    (success, out) = GET_PARENT_SEAL_BITMAP.staticcall(abi.encodePacked(blockNumber));
    require(success, "error calling getParentSealBitmap precompile");
    return getBytes32FromBytes(out, 0);
  }

  /**
   * @notice Verifies the BLS signature on the header and returns the seal bitmap.
   * The validator set used for verification is retrieved based on the parent hash field of the
   * header.  If the parent hash is not in the blockchain, verification fails.
   * @param header RLP encoded header
   * @return Bitmap parent seal with set bits at indices correspoinding to signing validators.
   */
  function getVerifiedSealBitmapFromHeader(bytes memory header) public view returns (bytes32) {
    bytes memory out;
    bool success;
    (success, out) = GET_VERIFIED_SEAL_BITMAP.staticcall(abi.encodePacked(header));
    require(success, "error calling getVerifiedSealBitmapFromHeader precompile");
    return getBytes32FromBytes(out, 0);
  }

  /**
   * @notice Converts bytes to uint256.
   * @param bs byte[] data
   * @param start offset into byte data to convert
   * @return uint256 data
   */
  function getUint256FromBytes(bytes memory bs, uint256 start) internal pure returns (uint256) {
    return uint256(getBytes32FromBytes(bs, start));
  }

  /**
   * @notice Converts bytes to bytes32.
   * @param bs byte[] data
   * @param start offset into byte data to convert
   * @return bytes32 data
   */
  function getBytes32FromBytes(bytes memory bs, uint256 start) internal pure returns (bytes32) {
    require(bs.length >= start.add(32), "slicing out of range");
    bytes32 x;
    assembly {
      x := mload(add(bs, add(start, 32)))
    }
    return x;
  }

  /**
   * @notice Returns the minimum number of required signers for a given block number.
   * @dev Computed in celo-blockchain as int(math.Ceil(float64(2*valSet.Size()) / 3))
   */
  function minQuorumSize(uint256 blockNumber) public view returns (uint256) {
    return numberValidatorsInSet(blockNumber).mul(2).add(2).div(3);
  }

  /**
   * @notice Computes byzantine quorum from current validator set size
   * @return Byzantine quorum of validators.
   */
  function minQuorumSizeInCurrentSet() public view returns (uint256) {
    return minQuorumSize(block.number);
  }
}
          

/project:/contracts/common/UsingRegistry.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.5.13;

import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";

import "./interfaces/IAccounts.sol";
import "./interfaces/IFeeCurrencyWhitelist.sol";
import "./interfaces/IFreezer.sol";
import "./interfaces/IRegistry.sol";

import "../governance/interfaces/IElection.sol";
import "../governance/interfaces/IGovernance.sol";
import "../governance/interfaces/ILockedGold.sol";
import "../governance/interfaces/IValidators.sol";

import "../identity/interfaces/IRandom.sol";
import "../identity/interfaces/IAttestations.sol";

import "../../lib/mento-core/contracts/interfaces/IExchange.sol";
import "../../lib/mento-core/contracts/interfaces/IReserve.sol";
import "../../lib/mento-core/contracts/interfaces/IStableToken.sol";
import "../stability/interfaces/ISortedOracles.sol";

contract UsingRegistry is Ownable {
  event RegistrySet(address indexed registryAddress);

  // solhint-disable state-visibility
  bytes32 constant ACCOUNTS_REGISTRY_ID = keccak256(abi.encodePacked("Accounts"));
  bytes32 constant ATTESTATIONS_REGISTRY_ID = keccak256(abi.encodePacked("Attestations"));
  bytes32 constant DOWNTIME_SLASHER_REGISTRY_ID = keccak256(abi.encodePacked("DowntimeSlasher"));
  bytes32 constant DOUBLE_SIGNING_SLASHER_REGISTRY_ID = keccak256(
    abi.encodePacked("DoubleSigningSlasher")
  );
  bytes32 constant ELECTION_REGISTRY_ID = keccak256(abi.encodePacked("Election"));
  bytes32 constant EXCHANGE_REGISTRY_ID = keccak256(abi.encodePacked("Exchange"));
  bytes32 constant FEE_CURRENCY_WHITELIST_REGISTRY_ID = keccak256(
    abi.encodePacked("FeeCurrencyWhitelist")
  );
  bytes32 constant FREEZER_REGISTRY_ID = keccak256(abi.encodePacked("Freezer"));
  bytes32 constant GOLD_TOKEN_REGISTRY_ID = keccak256(abi.encodePacked("GoldToken"));
  bytes32 constant GOVERNANCE_REGISTRY_ID = keccak256(abi.encodePacked("Governance"));
  bytes32 constant GOVERNANCE_SLASHER_REGISTRY_ID = keccak256(
    abi.encodePacked("GovernanceSlasher")
  );
  bytes32 constant LOCKED_GOLD_REGISTRY_ID = keccak256(abi.encodePacked("LockedGold"));
  bytes32 constant RESERVE_REGISTRY_ID = keccak256(abi.encodePacked("Reserve"));
  bytes32 constant RANDOM_REGISTRY_ID = keccak256(abi.encodePacked("Random"));
  bytes32 constant SORTED_ORACLES_REGISTRY_ID = keccak256(abi.encodePacked("SortedOracles"));
  bytes32 constant STABLE_TOKEN_REGISTRY_ID = keccak256(abi.encodePacked("StableToken"));
  bytes32 constant VALIDATORS_REGISTRY_ID = keccak256(abi.encodePacked("Validators"));
  // solhint-enable state-visibility

  IRegistry public registry;

  modifier onlyRegisteredContract(bytes32 identifierHash) {
    require(registry.getAddressForOrDie(identifierHash) == msg.sender, "only registered contract");
    _;
  }

  modifier onlyRegisteredContracts(bytes32[] memory identifierHashes) {
    require(registry.isOneOf(identifierHashes, msg.sender), "only registered contracts");
    _;
  }

  /**
   * @notice Updates the address pointing to a Registry contract.
   * @param registryAddress The address of a registry contract for routing to other contracts.
   */
  function setRegistry(address registryAddress) public onlyOwner {
    require(registryAddress != address(0), "Cannot register the null address");
    registry = IRegistry(registryAddress);
    emit RegistrySet(registryAddress);
  }

  function getAccounts() internal view returns (IAccounts) {
    return IAccounts(registry.getAddressForOrDie(ACCOUNTS_REGISTRY_ID));
  }

  function getAttestations() internal view returns (IAttestations) {
    return IAttestations(registry.getAddressForOrDie(ATTESTATIONS_REGISTRY_ID));
  }

  function getElection() internal view returns (IElection) {
    return IElection(registry.getAddressForOrDie(ELECTION_REGISTRY_ID));
  }

  function getExchange() internal view returns (IExchange) {
    return IExchange(registry.getAddressForOrDie(EXCHANGE_REGISTRY_ID));
  }

  function getFeeCurrencyWhitelistRegistry() internal view returns (IFeeCurrencyWhitelist) {
    return IFeeCurrencyWhitelist(registry.getAddressForOrDie(FEE_CURRENCY_WHITELIST_REGISTRY_ID));
  }

  function getFreezer() internal view returns (IFreezer) {
    return IFreezer(registry.getAddressForOrDie(FREEZER_REGISTRY_ID));
  }

  function getGoldToken() internal view returns (IERC20) {
    return IERC20(registry.getAddressForOrDie(GOLD_TOKEN_REGISTRY_ID));
  }

  function getGovernance() internal view returns (IGovernance) {
    return IGovernance(registry.getAddressForOrDie(GOVERNANCE_REGISTRY_ID));
  }

  function getLockedGold() internal view returns (ILockedGold) {
    return ILockedGold(registry.getAddressForOrDie(LOCKED_GOLD_REGISTRY_ID));
  }

  function getRandom() internal view returns (IRandom) {
    return IRandom(registry.getAddressForOrDie(RANDOM_REGISTRY_ID));
  }

  function getReserve() internal view returns (IReserve) {
    return IReserve(registry.getAddressForOrDie(RESERVE_REGISTRY_ID));
  }

  function getSortedOracles() internal view returns (ISortedOracles) {
    return ISortedOracles(registry.getAddressForOrDie(SORTED_ORACLES_REGISTRY_ID));
  }

  function getStableToken() internal view returns (IStableToken) {
    return IStableToken(registry.getAddressForOrDie(STABLE_TOKEN_REGISTRY_ID));
  }

  function getValidators() internal view returns (IValidators) {
    return IValidators(registry.getAddressForOrDie(VALIDATORS_REGISTRY_ID));
  }
}
          

/project:/contracts/common/interfaces/IAccounts.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IAccounts {
  function isAccount(address) external view returns (bool);
  function voteSignerToAccount(address) external view returns (address);
  function validatorSignerToAccount(address) external view returns (address);
  function attestationSignerToAccount(address) external view returns (address);
  function signerToAccount(address) external view returns (address);
  function getAttestationSigner(address) external view returns (address);
  function getValidatorSigner(address) external view returns (address);
  function getVoteSigner(address) external view returns (address);
  function hasAuthorizedVoteSigner(address) external view returns (bool);
  function hasAuthorizedValidatorSigner(address) external view returns (bool);
  function hasAuthorizedAttestationSigner(address) external view returns (bool);

  function setAccountDataEncryptionKey(bytes calldata) external;
  function setMetadataURL(string calldata) external;
  function setName(string calldata) external;
  function setWalletAddress(address, uint8, bytes32, bytes32) external;
  function setAccount(string calldata, bytes calldata, address, uint8, bytes32, bytes32) external;

  function getDataEncryptionKey(address) external view returns (bytes memory);
  function getWalletAddress(address) external view returns (address);
  function getMetadataURL(address) external view returns (string memory);
  function batchGetMetadataURL(address[] calldata)
    external
    view
    returns (uint256[] memory, bytes memory);
  function getName(address) external view returns (string memory);

  function authorizeVoteSigner(address, uint8, bytes32, bytes32) external;
  function authorizeValidatorSigner(address, uint8, bytes32, bytes32) external;
  function authorizeValidatorSignerWithPublicKey(address, uint8, bytes32, bytes32, bytes calldata)
    external;
  function authorizeValidatorSignerWithKeys(
    address,
    uint8,
    bytes32,
    bytes32,
    bytes calldata,
    bytes calldata,
    bytes calldata
  ) external;
  function authorizeAttestationSigner(address, uint8, bytes32, bytes32) external;
  function createAccount() external returns (bool);

  function setPaymentDelegation(address, uint256) external;
  function getPaymentDelegation(address) external view returns (address, uint256);
  function isSigner(address, address, bytes32) external view returns (bool);
}
          

/project:/contracts/common/interfaces/ICeloVersionedContract.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface ICeloVersionedContract {
  /**
   * @notice Returns the storage, major, minor, and patch version of the contract.
    * @return Storage version of the contract.
    * @return Major version of the contract.
    * @return Minor version of the contract.
    * @return Patch version of the contract.
   */
  function getVersionNumber() external pure returns (uint256, uint256, uint256, uint256);
}
          

/project:/contracts/common/interfaces/IFeeCurrencyWhitelist.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IFeeCurrencyWhitelist {
  function addToken(address) external;
  function getWhitelist() external view returns (address[] memory);
}
          

/project:/contracts/common/interfaces/IFreezer.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IFreezer {
  function isFrozen(address) external view returns (bool);
}
          

/project:/contracts/common/interfaces/IRegistry.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IRegistry {
  function setAddressFor(string calldata, address) external;
  function getAddressForOrDie(bytes32) external view returns (address);
  function getAddressFor(bytes32) external view returns (address);
  function getAddressForStringOrDie(string calldata identifier) external view returns (address);
  function getAddressForString(string calldata identifier) external view returns (address);
  function isOneOf(bytes32[] calldata, address) external view returns (bool);
}
          

/project:/contracts/common/libraries/ReentrancyGuard.sol

pragma solidity ^0.5.13;

/**
 * @title Helps contracts guard against reentrancy attacks.
 * @author Remco Bloemen <remco@2π.com>, Eenae <alexey@mixbytes.io>
 * @dev If you mark a function `nonReentrant`, you should also
 * mark it `external`.
 */
contract ReentrancyGuard {
  /// @dev counter to allow mutex lock with only one SSTORE operation
  uint256 private _guardCounter;

  constructor() internal {
    // The counter starts at one to prevent changing it from zero to a non-zero
    // value, which is a more expensive operation.
    _guardCounter = 1;
  }

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

/project:/contracts/common/linkedlists/IntegerSortedLinkedList.sol

pragma solidity ^0.5.13;

import "openzeppelin-solidity/contracts/math/SafeMath.sol";

import "./SortedLinkedList.sol";

/**
 * @title Maintains a sorted list of unsigned ints keyed by uint256.
 */
library IntegerSortedLinkedList {
  using SafeMath for uint256;
  using SortedLinkedList for SortedLinkedList.List;

  /**
   * @notice Inserts an element into a doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to insert.
   * @param value The element value.
   * @param lesserKey The key of the element less than the element to insert.
   * @param greaterKey The key of the element greater than the element to insert.
   */
  function insert(
    SortedLinkedList.List storage list,
    uint256 key,
    uint256 value,
    uint256 lesserKey,
    uint256 greaterKey
  ) public {
    list.insert(bytes32(key), value, bytes32(lesserKey), bytes32(greaterKey));
  }

  /**
   * @notice Removes an element from the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to remove.
   */
  function remove(SortedLinkedList.List storage list, uint256 key) public {
    list.remove(bytes32(key));
  }

  /**
   * @notice Updates an element in the list.
   * @param list A storage pointer to the underlying list.
   * @param key The element key.
   * @param value The element value.
   * @param lesserKey The key of the element will be just left of `key` after the update.
   * @param greaterKey The key of the element will be just right of `key` after the update.
   * @dev Note that only one of "lesserKey" or "greaterKey" needs to be correct to reduce friction.
   */
  function update(
    SortedLinkedList.List storage list,
    uint256 key,
    uint256 value,
    uint256 lesserKey,
    uint256 greaterKey
  ) public {
    list.update(bytes32(key), value, bytes32(lesserKey), bytes32(greaterKey));
  }

  /**
   * @notice Inserts an element at the end of the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to insert.
   */
  function push(SortedLinkedList.List storage list, uint256 key) public {
    list.push(bytes32(key));
  }

  /**
   * @notice Removes N elements from the head of the list and returns their keys.
   * @param list A storage pointer to the underlying list.
   * @param n The number of elements to pop.
   * @return The keys of the popped elements.
   */
  function popN(SortedLinkedList.List storage list, uint256 n) public returns (uint256[] memory) {
    bytes32[] memory byteKeys = list.popN(n);
    uint256[] memory keys = new uint256[](byteKeys.length);
    for (uint256 i = 0; i < byteKeys.length; i = i.add(1)) {
      keys[i] = uint256(byteKeys[i]);
    }
    return keys;
  }

  /**
   * @notice Returns whether or not a particular key is present in the sorted list.
   * @param list A storage pointer to the underlying list.
   * @param key The element key.
   * @return Whether or not the key is in the sorted list.
   */
  function contains(SortedLinkedList.List storage list, uint256 key) public view returns (bool) {
    return list.contains(bytes32(key));
  }

  /**
   * @notice Returns the value for a particular key in the sorted list.
   * @param list A storage pointer to the underlying list.
   * @param key The element key.
   * @return The element value.
   */
  function getValue(SortedLinkedList.List storage list, uint256 key) public view returns (uint256) {
    return list.getValue(bytes32(key));
  }

  /**
   * @notice Gets all elements from the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @return Array of all keys in the list.
   * @return Values corresponding to keys, which will be ordered largest to smallest.
   */
  function getElements(SortedLinkedList.List storage list)
    public
    view
    returns (uint256[] memory, uint256[] memory)
  {
    bytes32[] memory byteKeys = list.getKeys();
    uint256[] memory keys = new uint256[](byteKeys.length);
    uint256[] memory values = new uint256[](byteKeys.length);
    for (uint256 i = 0; i < byteKeys.length; i = i.add(1)) {
      keys[i] = uint256(byteKeys[i]);
      values[i] = list.values[byteKeys[i]];
    }
    return (keys, values);
  }
}
          

/project:/contracts/common/linkedlists/LinkedList.sol

pragma solidity ^0.5.13;

import "openzeppelin-solidity/contracts/math/SafeMath.sol";

/**
 * @title Maintains a doubly linked list keyed by bytes32.
 * @dev Following the `next` pointers will lead you to the head, rather than the tail.
 */
library LinkedList {
  using SafeMath for uint256;

  struct Element {
    bytes32 previousKey;
    bytes32 nextKey;
    bool exists;
  }

  struct List {
    bytes32 head;
    bytes32 tail;
    uint256 numElements;
    mapping(bytes32 => Element) elements;
  }

  /**
   * @notice Inserts an element into a doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to insert.
   * @param previousKey The key of the element that comes before the element to insert.
   * @param nextKey The key of the element that comes after the element to insert.
   */
  function insert(List storage list, bytes32 key, bytes32 previousKey, bytes32 nextKey) internal {
    require(key != bytes32(0), "Key must be defined");
    require(!contains(list, key), "Can't insert an existing element");
    require(
      previousKey != key && nextKey != key,
      "Key cannot be the same as previousKey or nextKey"
    );

    Element storage element = list.elements[key];
    element.exists = true;

    if (list.numElements == 0) {
      list.tail = key;
      list.head = key;
    } else {
      require(
        previousKey != bytes32(0) || nextKey != bytes32(0),
        "Either previousKey or nextKey must be defined"
      );

      element.previousKey = previousKey;
      element.nextKey = nextKey;

      if (previousKey != bytes32(0)) {
        require(
          contains(list, previousKey),
          "If previousKey is defined, it must exist in the list"
        );
        Element storage previousElement = list.elements[previousKey];
        require(previousElement.nextKey == nextKey, "previousKey must be adjacent to nextKey");
        previousElement.nextKey = key;
      } else {
        list.tail = key;
      }

      if (nextKey != bytes32(0)) {
        require(contains(list, nextKey), "If nextKey is defined, it must exist in the list");
        Element storage nextElement = list.elements[nextKey];
        require(nextElement.previousKey == previousKey, "previousKey must be adjacent to nextKey");
        nextElement.previousKey = key;
      } else {
        list.head = key;
      }
    }

    list.numElements = list.numElements.add(1);
  }

  /**
   * @notice Inserts an element at the tail of the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to insert.
   */
  function push(List storage list, bytes32 key) internal {
    insert(list, key, bytes32(0), list.tail);
  }

  /**
   * @notice Removes an element from the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to remove.
   */
  function remove(List storage list, bytes32 key) internal {
    Element storage element = list.elements[key];
    require(key != bytes32(0) && contains(list, key), "key not in list");
    if (element.previousKey != bytes32(0)) {
      Element storage previousElement = list.elements[element.previousKey];
      previousElement.nextKey = element.nextKey;
    } else {
      list.tail = element.nextKey;
    }

    if (element.nextKey != bytes32(0)) {
      Element storage nextElement = list.elements[element.nextKey];
      nextElement.previousKey = element.previousKey;
    } else {
      list.head = element.previousKey;
    }

    delete list.elements[key];
    list.numElements = list.numElements.sub(1);
  }

  /**
   * @notice Updates an element in the list.
   * @param list A storage pointer to the underlying list.
   * @param key The element key.
   * @param previousKey The key of the element that comes before the updated element.
   * @param nextKey The key of the element that comes after the updated element.
   */
  function update(List storage list, bytes32 key, bytes32 previousKey, bytes32 nextKey) internal {
    require(
      key != bytes32(0) && key != previousKey && key != nextKey && contains(list, key),
      "key on in list"
    );
    remove(list, key);
    insert(list, key, previousKey, nextKey);
  }

  /**
   * @notice Returns whether or not a particular key is present in the sorted list.
   * @param list A storage pointer to the underlying list.
   * @param key The element key.
   * @return Whether or not the key is in the sorted list.
   */
  function contains(List storage list, bytes32 key) internal view returns (bool) {
    return list.elements[key].exists;
  }

  /**
   * @notice Returns the keys of the N elements at the head of the list.
   * @param list A storage pointer to the underlying list.
   * @param n The number of elements to return.
   * @return The keys of the N elements at the head of the list.
   * @dev Reverts if n is greater than the number of elements in the list.
   */
  function headN(List storage list, uint256 n) internal view returns (bytes32[] memory) {
    require(n <= list.numElements, "not enough elements");
    bytes32[] memory keys = new bytes32[](n);
    bytes32 key = list.head;
    for (uint256 i = 0; i < n; i = i.add(1)) {
      keys[i] = key;
      key = list.elements[key].previousKey;
    }
    return keys;
  }

  /**
   * @notice Gets all element keys from the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @return All element keys from head to tail.
   */
  function getKeys(List storage list) internal view returns (bytes32[] memory) {
    return headN(list, list.numElements);
  }
}
          

/project:/contracts/common/linkedlists/SortedLinkedList.sol

pragma solidity ^0.5.13;

import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "./LinkedList.sol";

/**
 * @title Maintains a sorted list of unsigned ints keyed by bytes32.
 */
library SortedLinkedList {
  using SafeMath for uint256;
  using LinkedList for LinkedList.List;

  struct List {
    LinkedList.List list;
    mapping(bytes32 => uint256) values;
  }

  /**
   * @notice Inserts an element into a doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to insert.
   * @param value The element value.
   * @param lesserKey The key of the element less than the element to insert.
   * @param greaterKey The key of the element greater than the element to insert.
   */
  function insert(
    List storage list,
    bytes32 key,
    uint256 value,
    bytes32 lesserKey,
    bytes32 greaterKey
  ) internal {
    require(
      key != bytes32(0) && key != lesserKey && key != greaterKey && !contains(list, key),
      "invalid key"
    );
    require(
      (lesserKey != bytes32(0) || greaterKey != bytes32(0)) || list.list.numElements == 0,
      "greater and lesser key zero"
    );
    require(contains(list, lesserKey) || lesserKey == bytes32(0), "invalid lesser key");
    require(contains(list, greaterKey) || greaterKey == bytes32(0), "invalid greater key");
    (lesserKey, greaterKey) = getLesserAndGreater(list, value, lesserKey, greaterKey);
    list.list.insert(key, lesserKey, greaterKey);
    list.values[key] = value;
  }

  /**
   * @notice Removes an element from the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to remove.
   */
  function remove(List storage list, bytes32 key) internal {
    list.list.remove(key);
    list.values[key] = 0;
  }

  /**
   * @notice Updates an element in the list.
   * @param list A storage pointer to the underlying list.
   * @param key The element key.
   * @param value The element value.
   * @param lesserKey The key of the element will be just left of `key` after the update.
   * @param greaterKey The key of the element will be just right of `key` after the update.
   * @dev Note that only one of "lesserKey" or "greaterKey" needs to be correct to reduce friction.
   */
  function update(
    List storage list,
    bytes32 key,
    uint256 value,
    bytes32 lesserKey,
    bytes32 greaterKey
  ) internal {
    remove(list, key);
    insert(list, key, value, lesserKey, greaterKey);
  }

  /**
   * @notice Inserts an element at the tail of the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @param key The key of the element to insert.
   */
  function push(List storage list, bytes32 key) internal {
    insert(list, key, 0, bytes32(0), list.list.tail);
  }

  /**
   * @notice Removes N elements from the head of the list and returns their keys.
   * @param list A storage pointer to the underlying list.
   * @param n The number of elements to pop.
   * @return The keys of the popped elements.
   */
  function popN(List storage list, uint256 n) internal returns (bytes32[] memory) {
    require(n <= list.list.numElements, "not enough elements");
    bytes32[] memory keys = new bytes32[](n);
    for (uint256 i = 0; i < n; i = i.add(1)) {
      bytes32 key = list.list.head;
      keys[i] = key;
      remove(list, key);
    }
    return keys;
  }

  /**
   * @notice Returns whether or not a particular key is present in the sorted list.
   * @param list A storage pointer to the underlying list.
   * @param key The element key.
   * @return Whether or not the key is in the sorted list.
   */
  function contains(List storage list, bytes32 key) internal view returns (bool) {
    return list.list.contains(key);
  }

  /**
   * @notice Returns the value for a particular key in the sorted list.
   * @param list A storage pointer to the underlying list.
   * @param key The element key.
   * @return The element value.
   */
  function getValue(List storage list, bytes32 key) internal view returns (uint256) {
    return list.values[key];
  }

  /**
   * @notice Gets all elements from the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @return Array of all keys in the list.
   * @return Values corresponding to keys, which will be ordered largest to smallest.
   */
  function getElements(List storage list)
    internal
    view
    returns (bytes32[] memory, uint256[] memory)
  {
    bytes32[] memory keys = getKeys(list);
    uint256[] memory values = new uint256[](keys.length);
    for (uint256 i = 0; i < keys.length; i = i.add(1)) {
      values[i] = list.values[keys[i]];
    }
    return (keys, values);
  }

  /**
   * @notice Gets all element keys from the doubly linked list.
   * @param list A storage pointer to the underlying list.
   * @return All element keys from head to tail.
   */
  function getKeys(List storage list) internal view returns (bytes32[] memory) {
    return list.list.getKeys();
  }

  /**
   * @notice Returns first N greatest elements of the list.
   * @param list A storage pointer to the underlying list.
   * @param n The number of elements to return.
   * @return The keys of the first n elements.
   * @dev Reverts if n is greater than the number of elements in the list.
   */
  function headN(List storage list, uint256 n) internal view returns (bytes32[] memory) {
    return list.list.headN(n);
  }

  /**
   * @notice Returns the keys of the elements greaterKey than and less than the provided value.
   * @param list A storage pointer to the underlying list.
   * @param value The element value.
   * @param lesserKey The key of the element which could be just left of the new value.
   * @param greaterKey The key of the element which could be just right of the new value.
   * @return The correct lesserKey keys.
   * @return The correct greaterKey keys.
   */
  function getLesserAndGreater(
    List storage list,
    uint256 value,
    bytes32 lesserKey,
    bytes32 greaterKey
  ) private view returns (bytes32, bytes32) {
    // Check for one of the following conditions and fail if none are met:
    //   1. The value is less than the current lowest value
    //   2. The value is greater than the current greatest value
    //   3. The value is just greater than the value for `lesserKey`
    //   4. The value is just less than the value for `greaterKey`
    if (lesserKey == bytes32(0) && isValueBetween(list, value, lesserKey, list.list.tail)) {
      return (lesserKey, list.list.tail);
    } else if (
      greaterKey == bytes32(0) && isValueBetween(list, value, list.list.head, greaterKey)
    ) {
      return (list.list.head, greaterKey);
    } else if (
      lesserKey != bytes32(0) &&
      isValueBetween(list, value, lesserKey, list.list.elements[lesserKey].nextKey)
    ) {
      return (lesserKey, list.list.elements[lesserKey].nextKey);
    } else if (
      greaterKey != bytes32(0) &&
      isValueBetween(list, value, list.list.elements[greaterKey].previousKey, greaterKey)
    ) {
      return (list.list.elements[greaterKey].previousKey, greaterKey);
    } else {
      require(false, "get lesser and greater failure");
    }
  }

  /**
   * @notice Returns whether or not a given element is between two other elements.
   * @param list A storage pointer to the underlying list.
   * @param value The element value.
   * @param lesserKey The key of the element whose value should be lesserKey.
   * @param greaterKey The key of the element whose value should be greaterKey.
   * @return True if the given element is between the two other elements.
   */
  function isValueBetween(List storage list, uint256 value, bytes32 lesserKey, bytes32 greaterKey)
    private
    view
    returns (bool)
  {
    bool isLesser = lesserKey == bytes32(0) || list.values[lesserKey] <= value;
    bool isGreater = greaterKey == bytes32(0) || list.values[greaterKey] >= value;
    return isLesser && isGreater;
  }
}
          

/project:/contracts/governance/Proposals.sol

pragma solidity ^0.5.13;

import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "openzeppelin-solidity/contracts/utils/Address.sol";
import "solidity-bytes-utils/contracts/BytesLib.sol";

import "../common/FixidityLib.sol";

/**
 * @title A library operating on Celo Governance proposals.
 */
library Proposals {
  using FixidityLib for FixidityLib.Fraction;
  using SafeMath for uint256;
  using BytesLib for bytes;

  enum Stage { None, Queued, Approval, Referendum, Execution, Expiration }

  enum VoteValue { None, Abstain, No, Yes }

  struct StageDurations {
    uint256 approval;
    uint256 referendum;
    uint256 execution;
  }

  struct VoteTotals {
    uint256 yes;
    uint256 no;
    uint256 abstain;
  }

  struct Transaction {
    uint256 value;
    address destination;
    bytes data;
  }

  struct Proposal {
    address proposer;
    uint256 deposit;
    uint256 timestamp;
    VoteTotals votes;
    Transaction[] transactions;
    bool approved;
    uint256 networkWeight;
    string descriptionUrl;
  }

  /**
   * @notice Constructs a proposal.
   * @param proposal The proposal struct to be constructed.
   * @param values The values of CELO to be sent in the proposed transactions.
   * @param destinations The destination addresses of the proposed transactions.
   * @param data The concatenated data to be included in the proposed transactions.
   * @param dataLengths The lengths of each transaction's data.
   * @param proposer The proposer.
   * @param deposit The proposal deposit.
   */
  function make(
    Proposal storage proposal,
    uint256[] memory values,
    address[] memory destinations,
    bytes memory data,
    uint256[] memory dataLengths,
    address proposer,
    uint256 deposit
  ) public {
    require(
      values.length == destinations.length && destinations.length == dataLengths.length,
      "Array length mismatch"
    );
    uint256 transactionCount = values.length;

    proposal.proposer = proposer;
    proposal.deposit = deposit;
    // solhint-disable-next-line not-rely-on-time
    proposal.timestamp = now;

    uint256 dataPosition = 0;
    delete proposal.transactions;
    for (uint256 i = 0; i < transactionCount; i = i.add(1)) {
      proposal.transactions.push(
        Transaction(values[i], destinations[i], data.slice(dataPosition, dataLengths[i]))
      );
      dataPosition = dataPosition.add(dataLengths[i]);
    }
  }

  function setDescriptionUrl(Proposal storage proposal, string memory descriptionUrl) internal {
    require(bytes(descriptionUrl).length != 0, "Description url must have non-zero length");
    proposal.descriptionUrl = descriptionUrl;
  }

  /**
   * @notice Constructs a proposal for use in memory.
   * @param values The values of CELO to be sent in the proposed transactions.
   * @param destinations The destination addresses of the proposed transactions.
   * @param data The concatenated data to be included in the proposed transactions.
   * @param dataLengths The lengths of each transaction's data.
   * @param proposer The proposer.
   * @param deposit The proposal deposit.
   */
  function makeMem(
    uint256[] memory values,
    address[] memory destinations,
    bytes memory data,
    uint256[] memory dataLengths,
    address proposer,
    uint256 deposit
  ) internal view returns (Proposal memory) {
    require(
      values.length == destinations.length && destinations.length == dataLengths.length,
      "Array length mismatch"
    );
    uint256 transactionCount = values.length;

    Proposal memory proposal;
    proposal.proposer = proposer;
    proposal.deposit = deposit;
    // solhint-disable-next-line not-rely-on-time
    proposal.timestamp = now;

    uint256 dataPosition = 0;
    proposal.transactions = new Transaction[](transactionCount);
    for (uint256 i = 0; i < transactionCount; i = i.add(1)) {
      proposal.transactions[i] = Transaction(
        values[i],
        destinations[i],
        data.slice(dataPosition, dataLengths[i])
      );
      dataPosition = dataPosition.add(dataLengths[i]);
    }
    return proposal;
  }

  /**
   * @notice Adds or changes a vote on a proposal.
   * @param proposal The proposal struct.
   * @param previousYesVotes The previous yes votes weight.
   * @param previousNoVotes The previous no votes weight.
   * @param previousAbstainVotes The previous abstain votes weight.
   * @param yesVotes The current yes votes weight.
   * @param noVotes The current no votes weight.
   * @param abstainVotes The current abstain votes weight.
   */
  function updateVote(
    Proposal storage proposal,
    uint256 previousYesVotes,
    uint256 previousNoVotes,
    uint256 previousAbstainVotes,
    uint256 yesVotes,
    uint256 noVotes,
    uint256 abstainVotes
  ) public {
    // Subtract previous vote.
    proposal.votes.yes = proposal.votes.yes.sub(previousYesVotes);
    proposal.votes.no = proposal.votes.no.sub(previousNoVotes);
    proposal.votes.abstain = proposal.votes.abstain.sub(previousAbstainVotes);

    // Add new vote.
    proposal.votes.yes = proposal.votes.yes.add(yesVotes);
    proposal.votes.no = proposal.votes.no.add(noVotes);
    proposal.votes.abstain = proposal.votes.abstain.add(abstainVotes);
  }

  /**
   * @notice Executes the proposal.
   * @param proposal The proposal struct.
   * @dev Reverts if any transaction fails.
   */
  function execute(Proposal storage proposal) public {
    executeTransactions(proposal.transactions);
  }

  /**
   * @notice Executes the proposal.
   * @param proposal The proposal struct.
   * @dev Reverts if any transaction fails.
   */
  function executeMem(Proposal memory proposal) internal {
    executeTransactions(proposal.transactions);
  }

  function executeTransactions(Transaction[] memory transactions) internal {
    for (uint256 i = 0; i < transactions.length; i = i.add(1)) {
      require(
        externalCall(
          transactions[i].destination,
          transactions[i].value,
          transactions[i].data.length,
          transactions[i].data
        ),
        "Proposal execution failed"
      );
    }
  }

  /**
   * @notice Computes the support ratio for a proposal with the quorum condition:
   *   If the total number of votes (yes + no + abstain) is less than the required number of votes,
   *   "no" votes are added to increase particiption to this level. The ratio of yes / (yes + no)
   *   votes is returned.
   * @param proposal The proposal struct.
   * @param quorum The minimum participation at which "no" votes are not added.
   * @return The support ratio with the quorum condition.
   */
  function getSupportWithQuorumPadding(
    Proposal storage proposal,
    FixidityLib.Fraction memory quorum
  ) internal view returns (FixidityLib.Fraction memory) {
    uint256 yesVotes = proposal.votes.yes;
    if (yesVotes == 0) {
      return FixidityLib.newFixed(0);
    }
    uint256 noVotes = proposal.votes.no;
    uint256 totalVotes = yesVotes.add(noVotes).add(proposal.votes.abstain);
    uint256 requiredVotes = quorum
      .multiply(FixidityLib.newFixed(proposal.networkWeight))
      .fromFixed();
    if (requiredVotes > totalVotes) {
      noVotes = noVotes.add(requiredVotes.sub(totalVotes));
    }
    return FixidityLib.newFixedFraction(yesVotes, yesVotes.add(noVotes));
  }

  /**
   * @notice Returns the number of votes cast on the proposal over the total number
   *   of votes in the network as a fraction.
   * @param proposal The proposal struct.
   * @return The participation of the proposal.
   */
  function getParticipation(Proposal storage proposal)
    internal
    view
    returns (FixidityLib.Fraction memory)
  {
    uint256 totalVotes = proposal.votes.yes.add(proposal.votes.no).add(proposal.votes.abstain);
    return FixidityLib.newFixedFraction(totalVotes, proposal.networkWeight);
  }

  /**
   * @notice Returns a specified transaction in a proposal.
   * @param proposal The proposal struct.
   * @param index The index of the specified transaction in the proposal's transaction list.
   * @return Transaction value.
   * @return Transaction destination.
   * @return Transaction data.
   */
  function getTransaction(Proposal storage proposal, uint256 index)
    public
    view
    returns (uint256, address, bytes memory)
  {
    require(index < proposal.transactions.length, "getTransaction: bad index");
    Transaction storage transaction = proposal.transactions[index];
    return (transaction.value, transaction.destination, transaction.data);
  }

  /**
   * @notice Returns an unpacked proposal struct with its transaction count.
   * @param proposal The proposal struct.
   * @return proposer
   * @return deposit
   * @return timestamp
   * @return transaction Transaction count.
   * @return description Description url.
   * @return networkWeight Network weight.
   */
  function unpack(Proposal storage proposal)
    internal
    view
    returns (address, uint256, uint256, uint256, string storage, uint256, bool)
  {
    return (
      proposal.proposer,
      proposal.deposit,
      proposal.timestamp,
      proposal.transactions.length,
      proposal.descriptionUrl,
      proposal.networkWeight,
      proposal.approved
    );
  }

  /**
   * @notice Returns the referendum vote totals for a proposal.
   * @param proposal The proposal struct.
   * @return The yes vote totals.
   * @return The no vote totals.
   * @return The abstain vote totals.
   */
  function getVoteTotals(Proposal storage proposal)
    internal
    view
    returns (uint256, uint256, uint256)
  {
    return (proposal.votes.yes, proposal.votes.no, proposal.votes.abstain);
  }

  /**
   * @notice Returns whether or not a proposal has been approved.
   * @param proposal The proposal struct.
   * @return Whether or not the proposal has been approved.
   */
  function isApproved(Proposal storage proposal) internal view returns (bool) {
    return proposal.approved;
  }

  /**
   * @notice Returns whether or not a proposal exists.
   * @param proposal The proposal struct.
   * @return Whether or not the proposal exists.
   */
  function exists(Proposal storage proposal) internal view returns (bool) {
    return proposal.timestamp > 0;
  }

  // call has been separated into its own function in order to take advantage
  // of the Solidity's code generator to produce a loop that copies tx.data into memory.
  /**
   * @notice Executes a function call.
   * @param value The value of CELO to be sent with the function call.
   * @param destination The destination address of the function call.
   * @param dataLength The length of the data to be included in the function call.
   * @param data The data to be included in the function call.
   */
  function externalCall(address destination, uint256 value, uint256 dataLength, bytes memory data)
    private
    returns (bool)
  {
    bool result;

    if (dataLength > 0) require(Address.isContract(destination), "Invalid contract address");

    /* solhint-disable no-inline-assembly */
    assembly {
      /* solhint-disable max-line-length */
      let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
      let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
      result := call(
        sub(gas, 34710), // 34710 is the value that solidity is currently emitting
        // It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
        // callNewAccountGas (25000, in case the destination address does not exist and needs creating)
        destination,
        value,
        d,
        dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
        x,
        0 // Output is ignored, therefore the output size is zero
      )
      /* solhint-enable max-line-length */
    }
    /* solhint-enable no-inline-assembly */
    return result;
  }
}
          

/project:/contracts/governance/interfaces/IElection.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IElection {
  function electValidatorSigners() external view returns (address[] memory);
  function electNValidatorSigners(uint256, uint256) external view returns (address[] memory);
  function vote(address, uint256, address, address) external returns (bool);
  function activate(address) external returns (bool);
  function revokeActive(address, uint256, address, address, uint256) external returns (bool);
  function revokeAllActive(address, address, address, uint256) external returns (bool);
  function revokePending(address, uint256, address, address, uint256) external returns (bool);
  function markGroupIneligible(address) external;
  function markGroupEligible(address, address, address) external;
  function allowedToVoteOverMaxNumberOfGroups(address) external returns (bool);
  function forceDecrementVotes(
    address,
    uint256,
    address[] calldata,
    address[] calldata,
    uint256[] calldata
  ) external returns (uint256);
  function setAllowedToVoteOverMaxNumberOfGroups(bool flag) external;

  // view functions
  function getElectableValidators() external view returns (uint256, uint256);
  function getElectabilityThreshold() external view returns (uint256);
  function getNumVotesReceivable(address) external view returns (uint256);
  function getTotalVotes() external view returns (uint256);
  function getActiveVotes() external view returns (uint256);
  function getTotalVotesByAccount(address) external view returns (uint256);
  function getPendingVotesForGroupByAccount(address, address) external view returns (uint256);
  function getActiveVotesForGroupByAccount(address, address) external view returns (uint256);
  function getTotalVotesForGroupByAccount(address, address) external view returns (uint256);
  function getActiveVoteUnitsForGroupByAccount(address, address) external view returns (uint256);
  function getTotalVotesForGroup(address) external view returns (uint256);
  function getActiveVotesForGroup(address) external view returns (uint256);
  function getPendingVotesForGroup(address) external view returns (uint256);
  function getGroupEligibility(address) external view returns (bool);
  function getGroupEpochRewards(address, uint256, uint256[] calldata)
    external
    view
    returns (uint256);
  function getGroupsVotedForByAccount(address) external view returns (address[] memory);
  function getEligibleValidatorGroups() external view returns (address[] memory);
  function getTotalVotesForEligibleValidatorGroups()
    external
    view
    returns (address[] memory, uint256[] memory);
  function getCurrentValidatorSigners() external view returns (address[] memory);
  function canReceiveVotes(address, uint256) external view returns (bool);
  function hasActivatablePendingVotes(address, address) external view returns (bool);
  function validatorSignerAddressFromCurrentSet(uint256 index) external view returns (address);
  function numberValidatorsInCurrentSet() external view returns (uint256);

  // only owner
  function setElectableValidators(uint256, uint256) external returns (bool);
  function setMaxNumGroupsVotedFor(uint256) external returns (bool);
  function setElectabilityThreshold(uint256) external returns (bool);

  // only VM
  function distributeEpochRewards(address, uint256, address, address) external;
}
          

/project:/contracts/governance/interfaces/IGovernance.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IGovernance {
  function removeVotesWhenRevokingDelegatedVotes(address account, uint256 maxAmountAllowed)
    external;
  function votePartially(
    uint256 proposalId,
    uint256 index,
    uint256 yesVotes,
    uint256 noVotes,
    uint256 abstainVotes
  ) external returns (bool);

  function isVoting(address) external view returns (bool);
  function getAmountOfGoldUsedForVoting(address account) external view returns (uint256);

  function getProposal(uint256 proposalId)
    external
    view
    returns (address, uint256, uint256, uint256, string memory, uint256, bool);

  function getReferendumStageDuration() external view returns (uint256);
}
          

/project:/contracts/governance/interfaces/ILockedGold.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface ILockedGold {
  function lock() external payable;
  function incrementNonvotingAccountBalance(address, uint256) external;
  function decrementNonvotingAccountBalance(address, uint256) external;
  function getAccountTotalLockedGold(address) external view returns (uint256);
  function getTotalLockedGold() external view returns (uint256);
  function getPendingWithdrawals(address)
    external
    view
    returns (uint256[] memory, uint256[] memory);
  function getPendingWithdrawal(address account, uint256 index)
    external
    view
    returns (uint256, uint256);
  function getTotalPendingWithdrawals(address) external view returns (uint256);
  function unlock(uint256) external;
  function relock(uint256, uint256) external;
  function withdraw(uint256) external;
  function slash(
    address account,
    uint256 penalty,
    address reporter,
    uint256 reward,
    address[] calldata lessers,
    address[] calldata greaters,
    uint256[] calldata indices
  ) external;
  function isSlasher(address) external view returns (bool);

  function getAccountTotalDelegatedFraction(address account) external view returns (uint256);

  function getAccountTotalGovernanceVotingPower(address account) external view returns (uint256);
  function unlockingPeriod() external view returns (uint256);
  function getAccountNonvotingLockedGold(address account) external view returns (uint256);
}
          

/project:/contracts/governance/interfaces/IValidators.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IValidators {
  function registerValidator(bytes calldata, bytes calldata, bytes calldata)
    external
    returns (bool);
  function deregisterValidator(uint256) external returns (bool);
  function affiliate(address) external returns (bool);
  function deaffiliate() external returns (bool);
  function updateBlsPublicKey(bytes calldata, bytes calldata) external returns (bool);
  function registerValidatorGroup(uint256) external returns (bool);
  function deregisterValidatorGroup(uint256) external returns (bool);
  function addMember(address) external returns (bool);
  function addFirstMember(address, address, address) external returns (bool);
  function removeMember(address) external returns (bool);
  function reorderMember(address, address, address) external returns (bool);
  function updateCommission() external;
  function setNextCommissionUpdate(uint256) external;
  function resetSlashingMultiplier() external;

  // only owner
  function setCommissionUpdateDelay(uint256) external;
  function setMaxGroupSize(uint256) external returns (bool);
  function setMembershipHistoryLength(uint256) external returns (bool);
  function setValidatorScoreParameters(uint256, uint256) external returns (bool);
  function setGroupLockedGoldRequirements(uint256, uint256) external returns (bool);
  function setValidatorLockedGoldRequirements(uint256, uint256) external returns (bool);
  function setSlashingMultiplierResetPeriod(uint256) external;

  // view functions
  function getMaxGroupSize() external view returns (uint256);
  function getCommissionUpdateDelay() external view returns (uint256);
  function getValidatorScoreParameters() external view returns (uint256, uint256);
  function getMembershipHistory(address)
    external
    view
    returns (uint256[] memory, address[] memory, uint256, uint256);
  function calculateEpochScore(uint256) external view returns (uint256);
  function calculateGroupEpochScore(uint256[] calldata) external view returns (uint256);
  function getAccountLockedGoldRequirement(address) external view returns (uint256);
  function meetsAccountLockedGoldRequirements(address) external view returns (bool);
  function getValidatorBlsPublicKeyFromSigner(address) external view returns (bytes memory);
  function getValidator(address account)
    external
    view
    returns (bytes memory, bytes memory, address, uint256, address);
  function getValidatorGroup(address)
    external
    view
    returns (address[] memory, uint256, uint256, uint256, uint256[] memory, uint256, uint256);
  function getGroupNumMembers(address) external view returns (uint256);
  function getTopGroupValidators(address, uint256) external view returns (address[] memory);
  function getGroupsNumMembers(address[] calldata accounts)
    external
    view
    returns (uint256[] memory);
  function getNumRegisteredValidators() external view returns (uint256);
  function groupMembershipInEpoch(address, uint256, uint256) external view returns (address);

  // only registered contract
  function updateEcdsaPublicKey(address, address, bytes calldata) external returns (bool);
  function updatePublicKeys(address, address, bytes calldata, bytes calldata, bytes calldata)
    external
    returns (bool);
  function getValidatorLockedGoldRequirements() external view returns (uint256, uint256);
  function getGroupLockedGoldRequirements() external view returns (uint256, uint256);
  function getRegisteredValidators() external view returns (address[] memory);
  function getRegisteredValidatorSigners() external view returns (address[] memory);
  function getRegisteredValidatorGroups() external view returns (address[] memory);
  function isValidatorGroup(address) external view returns (bool);
  function isValidator(address) external view returns (bool);
  function getValidatorGroupSlashingMultiplier(address) external view returns (uint256);
  function getMembershipInLastEpoch(address) external view returns (address);
  function getMembershipInLastEpochFromSigner(address) external view returns (address);

  // only VM
  function updateValidatorScoreFromSigner(address, uint256) external;
  function distributeEpochPaymentsFromSigner(address, uint256) external returns (uint256);

  // only slasher
  function forceDeaffiliateIfValidator(address) external;
  function halveSlashingMultiplier(address) external;

}
          

/project:/contracts/identity/interfaces/IAttestations.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IAttestations {
  function revoke(bytes32, uint256) external;
  function withdraw(address) external;

  // view functions
  function getUnselectedRequest(bytes32, address) external view returns (uint32, uint32, address);
  function getAttestationIssuers(bytes32, address) external view returns (address[] memory);
  function getAttestationStats(bytes32, address) external view returns (uint32, uint32);
  function batchGetAttestationStats(bytes32[] calldata)
    external
    view
    returns (uint256[] memory, address[] memory, uint64[] memory, uint64[] memory);
  function getAttestationState(bytes32, address, address)
    external
    view
    returns (uint8, uint32, address);
  function getCompletableAttestations(bytes32, address)
    external
    view
    returns (uint32[] memory, address[] memory, uint256[] memory, bytes memory);
  function getAttestationRequestFee(address) external view returns (uint256);
  function getMaxAttestations() external view returns (uint256);
  function validateAttestationCode(bytes32, address, uint8, bytes32, bytes32)
    external
    view
    returns (address);
  function lookupAccountsForIdentifier(bytes32) external view returns (address[] memory);
  function requireNAttestationsRequested(bytes32, address, uint32) external view;

  // only owner
  function setAttestationRequestFee(address, uint256) external;
  function setAttestationExpiryBlocks(uint256) external;
  function setSelectIssuersWaitBlocks(uint256) external;
  function setMaxAttestations(uint256) external;
}
          

/project:/contracts/identity/interfaces/IRandom.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface IRandom {
  function revealAndCommit(bytes32, bytes32, address) external;
  function randomnessBlockRetentionWindow() external view returns (uint256);
  function random() external view returns (bytes32);
  function getBlockRandomness(uint256) external view returns (bytes32);
}
          

/project:/contracts/stability/interfaces/ISortedOracles.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.5.13 <0.9.0;

interface ISortedOracles {
  function addOracle(address, address) external;
  function removeOracle(address, address, uint256) external;
  function report(address, uint256, address, address) external;
  function removeExpiredReports(address, uint256) external;
  function isOldestReportExpired(address token) external view returns (bool, address);
  function numRates(address) external view returns (uint256);
  function medianRate(address) external view returns (uint256, uint256);
  function numTimestamps(address) external view returns (uint256);
  function medianTimestamp(address) external view returns (uint256);
}
          

/project:/lib/mento-core/contracts/interfaces/IExchange.sol

pragma solidity ^0.5.13;

interface IExchange {
    function buy(
        uint256,
        uint256,
        bool
    ) external returns (uint256);

    function sell(
        uint256,
        uint256,
        bool
    ) external returns (uint256);

    function exchange(
        uint256,
        uint256,
        bool
    ) external returns (uint256);

    function setUpdateFrequency(uint256) external;

    function getBuyTokenAmount(uint256, bool) external view returns (uint256);

    function getSellTokenAmount(uint256, bool) external view returns (uint256);

    function getBuyAndSellBuckets(bool) external view returns (uint256, uint256);
}
          

/project:/lib/mento-core/contracts/interfaces/IReserve.sol

pragma solidity ^0.5.13;

interface IReserve {
    function setTobinTaxStalenessThreshold(uint256) external;

    function addToken(address) external returns (bool);

    function removeToken(address, uint256) external returns (bool);

    function transferGold(address payable, uint256) external returns (bool);

    function transferExchangeGold(address payable, uint256) external returns (bool);

    function getReserveGoldBalance() external view returns (uint256);

    function getUnfrozenReserveGoldBalance() external view returns (uint256);

    function getOrComputeTobinTax() external returns (uint256, uint256);

    function getTokens() external view returns (address[] memory);

    function getReserveRatio() external view returns (uint256);

    function addExchangeSpender(address) external;

    function removeExchangeSpender(address, uint256) external;

    function addSpender(address) external;

    function removeSpender(address) external;
}
          

/project:/lib/mento-core/contracts/interfaces/IStableToken.sol

pragma solidity ^0.5.13;

/**
 * @title This interface describes the functions specific to Celo Stable Tokens, and in the
 * absence of interface inheritance is intended as a companion to IERC20.sol and ICeloToken.sol.
 */
interface IStableToken {
    function mint(address, uint256) external returns (bool);

    function burn(uint256) external returns (bool);

    function setInflationParameters(uint256, uint256) external;

    function valueToUnits(uint256) external view returns (uint256);

    function unitsToValue(uint256) external view returns (uint256);

    function getInflationParameters()
        external
        view
        returns (
            uint256,
            uint256,
            uint256,
            uint256
        );

    // NOTE: duplicated with IERC20.sol, remove once interface inheritance is supported.
    function balanceOf(address) external view returns (uint256);
}
          

/solidity-bytes-utils/contracts/BytesLib.sol

/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <goncalo.sa@consensys.net>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */

pragma solidity ^0.5.0;


library BytesLib {
    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add 
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes_slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes_slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes_slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes_slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes_slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes_slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))
                
                for { 
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(
        bytes memory _bytes,
        uint _start,
        uint _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_bytes.length >= (_start + _length));

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint _start) internal  pure returns (address) {
        require(_bytes.length >= (_start + 20));
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint _start) internal  pure returns (uint8) {
        require(_bytes.length >= (_start + 1));
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint _start) internal  pure returns (uint16) {
        require(_bytes.length >= (_start + 2));
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint _start) internal  pure returns (uint32) {
        require(_bytes.length >= (_start + 4));
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint(bytes memory _bytes, uint _start) internal  pure returns (uint256) {
        require(_bytes.length >= (_start + 32));
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint _start) internal  pure returns (bytes32) {
        require(_bytes.length >= (_start + 32));
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    )
        internal
        view
        returns (bool)
    {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes_slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes_slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}
          

Compiler Settings

{"remappings":[],"optimizer":{"runs":200,"enabled":false},"metadata":{"useLiteralContent":true},"libraries":{},"evmVersion":"istanbul","compilationTarget":{"project:/contracts/governance/Governance.sol":"Governance"}}
              

Contract ABI

[{"type":"constructor","stateMutability":"nonpayable","payable":false,"inputs":[{"type":"bool","name":"test","internalType":"bool"}]},{"type":"event","name":"ApproverSet","inputs":[{"type":"address","name":"approver","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"ConcurrentProposalsSet","inputs":[{"type":"uint256","name":"concurrentProposals","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ConstitutionSet","inputs":[{"type":"address","name":"destination","internalType":"address","indexed":true},{"type":"bytes4","name":"functionId","internalType":"bytes4","indexed":true},{"type":"uint256","name":"threshold","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"DequeueFrequencySet","inputs":[{"type":"uint256","name":"dequeueFrequency","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ExecutionStageDurationSet","inputs":[{"type":"uint256","name":"executionStageDuration","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"HotfixApproved","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32","indexed":true}],"anonymous":false},{"type":"event","name":"HotfixExecuted","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32","indexed":true}],"anonymous":false},{"type":"event","name":"HotfixPrepared","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32","indexed":true},{"type":"uint256","name":"epoch","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"HotfixWhitelisted","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32","indexed":true},{"type":"address","name":"whitelister","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"MinDepositSet","inputs":[{"type":"uint256","name":"minDeposit","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"ParticipationBaselineQuorumFactorSet","inputs":[{"type":"uint256","name":"baselineQuorumFactor","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ParticipationBaselineUpdateFactorSet","inputs":[{"type":"uint256","name":"baselineUpdateFactor","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ParticipationBaselineUpdated","inputs":[{"type":"uint256","name":"participationBaseline","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ParticipationFloorSet","inputs":[{"type":"uint256","name":"participationFloor","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ProposalApproved","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"ProposalDequeued","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true},{"type":"uint256","name":"timestamp","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ProposalExecuted","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"ProposalExpired","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"ProposalQueued","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true},{"type":"address","name":"proposer","internalType":"address","indexed":true},{"type":"uint256","name":"transactionCount","internalType":"uint256","indexed":false},{"type":"uint256","name":"deposit","internalType":"uint256","indexed":false},{"type":"uint256","name":"timestamp","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ProposalUpvoteRevoked","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true},{"type":"address","name":"account","internalType":"address","indexed":true},{"type":"uint256","name":"revokedUpvotes","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ProposalUpvoted","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true},{"type":"address","name":"account","internalType":"address","indexed":true},{"type":"uint256","name":"upvotes","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ProposalVoteRevoked","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true},{"type":"address","name":"account","internalType":"address","indexed":true},{"type":"uint256","name":"value","internalType":"uint256","indexed":false},{"type":"uint256","name":"weight","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ProposalVoteRevokedV2","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true},{"type":"address","name":"account","internalType":"address","indexed":true},{"type":"uint256","name":"yesVotes","internalType":"uint256","indexed":false},{"type":"uint256","name":"noVotes","internalType":"uint256","indexed":false},{"type":"uint256","name":"abstainVotes","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ProposalVoted","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true},{"type":"address","name":"account","internalType":"address","indexed":true},{"type":"uint256","name":"value","internalType":"uint256","indexed":false},{"type":"uint256","name":"weight","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ProposalVotedV2","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256","indexed":true},{"type":"address","name":"account","internalType":"address","indexed":true},{"type":"uint256","name":"yesVotes","internalType":"uint256","indexed":false},{"type":"uint256","name":"noVotes","internalType":"uint256","indexed":false},{"type":"uint256","name":"abstainVotes","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"QueueExpirySet","inputs":[{"type":"uint256","name":"queueExpiry","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"ReferendumStageDurationSet","inputs":[{"type":"uint256","name":"referendumStageDuration","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"RegistrySet","inputs":[{"type":"address","name":"registryAddress","internalType":"address","indexed":true}],"anonymous":false},{"type":"fallback","stateMutability":"payable","payable":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"approve","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"},{"type":"uint256","name":"index","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"approveHotfix","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"address"}],"name":"approver","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"checkProofOfPossession","inputs":[{"type":"address","name":"sender","internalType":"address"},{"type":"bytes","name":"blsKey","internalType":"bytes"},{"type":"bytes","name":"blsPop","internalType":"bytes"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"concurrentProposals","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"dequeueFrequency","inputs":[],"constant":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"dequeueProposalsIfReady","inputs":[],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"dequeued","inputs":[{"type":"uint256","name":"","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"emptyIndices","inputs":[{"type":"uint256","name":"","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"execute","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"},{"type":"uint256","name":"index","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"executeHotfix","inputs":[{"type":"uint256[]","name":"values","internalType":"uint256[]"},{"type":"address[]","name":"destinations","internalType":"address[]"},{"type":"bytes","name":"data","internalType":"bytes"},{"type":"uint256[]","name":"dataLengths","internalType":"uint256[]"},{"type":"bytes32","name":"salt","internalType":"bytes32"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"}],"name":"fractionMulExp","inputs":[{"type":"uint256","name":"aNumerator","internalType":"uint256"},{"type":"uint256","name":"aDenominator","internalType":"uint256"},{"type":"uint256","name":"bNumerator","internalType":"uint256"},{"type":"uint256","name":"bDenominator","internalType":"uint256"},{"type":"uint256","name":"exponent","internalType":"uint256"},{"type":"uint256","name":"_decimals","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getAmountOfGoldUsedForVoting","inputs":[{"type":"address","name":"account","internalType":"address"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getBlockNumberFromHeader","inputs":[{"type":"bytes","name":"header","internalType":"bytes"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getConstitution","inputs":[{"type":"address","name":"destination","internalType":"address"},{"type":"bytes4","name":"functionId","internalType":"bytes4"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256[]","name":"","internalType":"uint256[]"}],"name":"getDequeue","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getEpochNumber","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getEpochNumberOfBlock","inputs":[{"type":"uint256","name":"blockNumber","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getEpochSize","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getExecutionStageDuration","inputs":[],"constant":true},{"type":"function","stateMutability":"pure","payable":false,"outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"getHotfixHash","inputs":[{"type":"uint256[]","name":"values","internalType":"uint256[]"},{"type":"address[]","name":"destinations","internalType":"address[]"},{"type":"bytes","name":"data","internalType":"bytes"},{"type":"uint256[]","name":"dataLengths","internalType":"uint256[]"},{"type":"bytes32","name":"salt","internalType":"bytes32"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"},{"type":"bool","name":"","internalType":"bool"},{"type":"uint256","name":"","internalType":"uint256"}],"name":"getHotfixRecord","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getMostRecentReferendumProposal","inputs":[{"type":"address","name":"account","internalType":"address"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"getParentSealBitmap","inputs":[{"type":"uint256","name":"blockNumber","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"}],"name":"getParticipationParameters","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"address"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"string","name":"","internalType":"string"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"bool","name":"","internalType":"bool"}],"name":"getProposal","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint8","name":"","internalType":"enum Proposals.Stage"}],"name":"getProposalStage","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"address","name":"","internalType":"address"},{"type":"bytes","name":"","internalType":"bytes"}],"name":"getProposalTransaction","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"},{"type":"uint256","name":"index","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256[]","name":"","internalType":"uint256[]"},{"type":"uint256[]","name":"","internalType":"uint256[]"}],"name":"getQueue","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getQueueLength","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getReferendumStageDuration","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"}],"name":"getUpvoteRecord","inputs":[{"type":"address","name":"account","internalType":"address"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getUpvotes","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"getVerifiedSealBitmapFromHeader","inputs":[{"type":"bytes","name":"header","internalType":"bytes"}],"constant":true},{"type":"function","stateMutability":"pure","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"}],"name":"getVersionNumber","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"}],"name":"getVoteRecord","inputs":[{"type":"address","name":"account","internalType":"address"},{"type":"uint256","name":"index","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"},{"type":"uint256","name":"","internalType":"uint256"}],"name":"getVoteTotals","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"hashHeader","inputs":[{"type":"bytes","name":"header","internalType":"bytes"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"hotfixWhitelistValidatorTally","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"executed","internalType":"bool"},{"type":"bool","name":"approved","internalType":"bool"},{"type":"uint256","name":"preparedEpoch","internalType":"uint256"}],"name":"hotfixes","inputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"constant":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"initialize","inputs":[{"type":"address","name":"registryAddress","internalType":"address"},{"type":"address","name":"_approver","internalType":"address"},{"type":"uint256","name":"_concurrentProposals","internalType":"uint256"},{"type":"uint256","name":"_minDeposit","internalType":"uint256"},{"type":"uint256","name":"_queueExpiry","internalType":"uint256"},{"type":"uint256","name":"_dequeueFrequency","internalType":"uint256"},{"type":"uint256","name":"referendumStageDuration","internalType":"uint256"},{"type":"uint256","name":"executionStageDuration","internalType":"uint256"},{"type":"uint256","name":"participationBaseline","internalType":"uint256"},{"type":"uint256","name":"participationFloor","internalType":"uint256"},{"type":"uint256","name":"baselineUpdateFactor","internalType":"uint256"},{"type":"uint256","name":"baselineQuorumFactor","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"initialized","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isApproved","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isDequeuedProposal","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"},{"type":"uint256","name":"index","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isDequeuedProposalExpired","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isHotfixPassing","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isHotfixWhitelistedBy","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32"},{"type":"address","name":"whitelister","internalType":"address"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isOwner","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isProposalPassing","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isQueued","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isQueuedProposalExpired","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isVoting","inputs":[{"type":"address","name":"account","internalType":"address"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"lastDequeue","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"minDeposit","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"minQuorumSize","inputs":[{"type":"uint256","name":"blockNumber","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"minQuorumSizeInCurrentSet","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"numberValidatorsInCurrentSet","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"numberValidatorsInSet","inputs":[{"type":"uint256","name":"blockNumber","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[],"constant":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"prepareHotfix","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"proposalCount","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"proposalExists","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"payable","payable":true,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"propose","inputs":[{"type":"uint256[]","name":"values","internalType":"uint256[]"},{"type":"address[]","name":"destinations","internalType":"address[]"},{"type":"bytes","name":"data","internalType":"bytes"},{"type":"uint256[]","name":"dataLengths","internalType":"uint256[]"},{"type":"string","name":"descriptionUrl","internalType":"string"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"queueExpiry","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"refundedDeposits","inputs":[{"type":"address","name":"","internalType":"address"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"contract IRegistry"}],"name":"registry","inputs":[],"constant":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"removeVotesWhenRevokingDelegatedVotes","inputs":[{"type":"address","name":"account","internalType":"address"},{"type":"uint256","name":"newVotingPower","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"renounceOwnership","inputs":[],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"revokeUpvote","inputs":[{"type":"uint256","name":"lesser","internalType":"uint256"},{"type":"uint256","name":"greater","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"revokeVotes","inputs":[],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setApprover","inputs":[{"type":"address","name":"_approver","internalType":"address"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setBaselineQuorumFactor","inputs":[{"type":"uint256","name":"baselineQuorumFactor","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setBaselineUpdateFactor","inputs":[{"type":"uint256","name":"baselineUpdateFactor","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setConcurrentProposals","inputs":[{"type":"uint256","name":"_concurrentProposals","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setConstitution","inputs":[{"type":"address","name":"destination","internalType":"address"},{"type":"bytes4","name":"functionId","internalType":"bytes4"},{"type":"uint256","name":"threshold","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setDequeueFrequency","inputs":[{"type":"uint256","name":"_dequeueFrequency","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setExecutionStageDuration","inputs":[{"type":"uint256","name":"executionStageDuration","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setMinDeposit","inputs":[{"type":"uint256","name":"_minDeposit","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setParticipationBaseline","inputs":[{"type":"uint256","name":"participationBaseline","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setParticipationFloor","inputs":[{"type":"uint256","name":"participationFloor","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setQueueExpiry","inputs":[{"type":"uint256","name":"_queueExpiry","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setReferendumStageDuration","inputs":[{"type":"uint256","name":"referendumStageDuration","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"setRegistry","inputs":[{"type":"address","name":"registryAddress","internalType":"address"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"approval","internalType":"uint256"},{"type":"uint256","name":"referendum","internalType":"uint256"},{"type":"uint256","name":"execution","internalType":"uint256"}],"name":"stageDurations","inputs":[],"constant":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"upvote","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"},{"type":"uint256","name":"lesser","internalType":"uint256"},{"type":"uint256","name":"greater","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"address"}],"name":"validatorSignerAddressFromCurrentSet","inputs":[{"type":"uint256","name":"index","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"address"}],"name":"validatorSignerAddressFromSet","inputs":[{"type":"uint256","name":"index","internalType":"uint256"},{"type":"uint256","name":"blockNumber","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"vote","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"},{"type":"uint256","name":"index","internalType":"uint256"},{"type":"uint8","name":"value","internalType":"enum Proposals.VoteValue"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"votePartially","inputs":[{"type":"uint256","name":"proposalId","internalType":"uint256"},{"type":"uint256","name":"index","internalType":"uint256"},{"type":"uint256","name":"yesVotes","internalType":"uint256"},{"type":"uint256","name":"noVotes","internalType":"uint256"},{"type":"uint256","name":"abstainVotes","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"whitelistHotfix","inputs":[{"type":"bytes32","name":"hash","internalType":"bytes32"}],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"withdraw","inputs":[],"constant":false}]
              

Contract Creation Code

0x60806040523480156200001157600080fd5b506040516200d4353803806200d435833981810160405260208110156200003757600080fd5b81019080805190602001909291905050508060006200005b6200012a60201b60201c565b9050806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a350806200011b576001600060146101000a81548160ff0219169083151502179055505b50600180819055505062000132565b600033905090565b61d2f380620001426000396000f3fe6080604052600436106104f75760003560e01c80637910867b1161028c578063b15f0f581161015a578063cea69e74116100cc578063e50e652d11610085578063e50e652d1461281e578063ec6830721461286d578063ed385274146128f5578063f2fde38b14612979578063f3f6da2c146129ca578063fae8db0a14612a25576104f7565b8063cea69e74146124a9578063cf48eb94146124e4578063d704f0c514612673578063da35c6641461276b578063df4da46114612796578063e41db455146127c1576104f7565b8063c134b2fc1161011e578063c134b2fc1461220e578063c73a6d7814612261578063c7f758a8146122b4578063c805956d146123c2578063c8d8d2b514612402578063cd845a761461243d576104f7565b8063b15f0f5814611f70578063b8f7700514611fab578063bab0808914611fd6578063bbb2eab914612179578063c0aee5f4146121e3576104f7565b806397b9eba6116101fe578063aa2feb83116101b7578063aa2feb8314611d39578063ad78c10914611d88578063add004df14611db3578063af108a0e14611e02578063af20311014611e5f578063b0f9984214611f35576104f7565b806397b9eba614611b5657806398f4270214611be45780639a7b3be714611c335780639b2b592f14611c5e5780639cb02dfc14611cad578063a91ee0dc14611ce8576104f7565b80638a883626116102505780638a8836261461195f5780638da5cb5b14611a3b5780638e905ed614611a925780638f32d59b14611abd5780638fcc9cfb14611aec5780639381ab2514611b27576104f7565b80637910867b146118005780637b103999146118535780638018556e146118aa57806381d4728d146118e557806387ee8a0f14611934576104f7565b80633fa5fed0116103c95780635f115a851161033b57806367960e91116102f457806367960e91146115f85780636de8a63b146116d45780636f2ab69314611740578063715018a6146117935780637385e5da146117aa57806377d26a2a146117d5576104f7565b80635f115a85146112175780635f8dd649146112a957806360b4d34d1461131257806365bbdaa0146113775780636643ac58146115585780636654716314611593576104f7565b80635601eaea1161038d5780635601eaea14610fd95780635733397814611036578063582ae53b1461109d5780635c759394146110fa5780635d180adb146111355780635d35a3d9146111ba576104f7565b80633fa5fed014610dba57806341b3d18514610e2d57806345a7849914610e585780634b2c2f4414610ebd57806354255be014610f99576104f7565b806323f0ab651161046d5780633156560e116104265780633156560e14610c46578063344944cf14610c975780633b1eb4bf14610cea5780633bb0ed2b14610d395780633ccfd60b14610d505780633db9dd9a14610d7f576104f7565b806323f0ab65146109165780632762132114610aad578063283aaefb14610b005780632c05235514610b655780632edfd12e14610ba057806330a095d014610c1b576104f7565b8063123633ea116104bf578063123633ea1461072a5780631374b22d146107a5578063141a8dd8146107f8578063152b48341461084f578063158ef93e146108ac5780631c65bc61146108db576104f7565b806301fce27e1461057257806304acaec9146106265780630e0b78ae146106615780630f717e42146106c65780631201a0fb146106ff575b60008036905014610570576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f756e6b6e6f776e206d6574686f6400000000000000000000000000000000000081525060200191505060405180910390fd5b005b34801561057e57600080fd5b50610587612a74565b604051808060200180602001838103835285818151815260200191508051906020019060200280838360005b838110156105ce5780820151818401526020810190506105b3565b50505050905001838103825284818151815260200191508051906020019060200280838360005b838110156106105780820151818401526020810190506105f5565b5050505090500194505050505060405180910390f35b34801561063257600080fd5b5061065f6004803603602081101561064957600080fd5b8101908080359060200190929190505050612c39565b005b34801561066d57600080fd5b5061069a6004803603602081101561068457600080fd5b8101908080359060200190929190505050612e11565b604051808415151515815260200183151515158152602001828152602001935050505060405180910390f35b3480156106d257600080fd5b506106db612e82565b60405180848152602001838152602001828152602001935050505060405180910390f35b34801561070b57600080fd5b50610714612e9a565b6040518082815260200191505060405180910390f35b34801561073657600080fd5b506107636004803603602081101561074d57600080fd5b8101908080359060200190929190505050612ea0565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b3480156107b157600080fd5b506107de600480360360208110156107c857600080fd5b8101908080359060200190929190505050612ff1565b604051808215151515815260200191505060405180910390f35b34801561080457600080fd5b5061080d613015565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561085b57600080fd5b506108926004803603604081101561087257600080fd5b81019080803590602001909291908035906020019092919050505061303b565b604051808215151515815260200191505060405180910390f35b3480156108b857600080fd5b506108c1613062565b604051808215151515815260200191505060405180910390f35b3480156108e757600080fd5b50610914600480360360208110156108fe57600080fd5b8101908080359060200190929190505050613075565b005b34801561092257600080fd5b50610a936004803603606081101561093957600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019064010000000081111561097657600080fd5b82018360208201111561098857600080fd5b803590602001918460018302840111640100000000831117156109aa57600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f82011690508083019250505050505050919291929080359060200190640100000000811115610a0d57600080fd5b820183602082011115610a1f57600080fd5b80359060200191846001830284011164010000000083111715610a4157600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509192919290505050613230565b604051808215151515815260200191505060405180910390f35b348015610ab957600080fd5b50610ae660048036036020811015610ad057600080fd5b81019080803590602001909291905050506133e9565b604051808215151515815260200191505060405180910390f35b348015610b0c57600080fd5b50610b4f60048036036020811015610b2357600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061340d565b6040518082815260200191505060405180910390f35b348015610b7157600080fd5b50610b9e60048036036020811015610b8857600080fd5b8101908080359060200190929190505050613459565b005b348015610bac57600080fd5b50610c01600480360360a0811015610bc357600080fd5b8101908080359060200190929190803590602001909291908035906020019092919080359060200190929190803590602001909291905050506135e6565b604051808215151515815260200191505060405180910390f35b348015610c2757600080fd5b50610c30613958565b6040518082815260200191505060405180910390f35b348015610c5257600080fd5b50610c9560048036036020811015610c6957600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050613965565b005b348015610ca357600080fd5b50610cd060048036036020811015610cba57600080fd5b8101908080359060200190929190505050613bcd565b604051808215151515815260200191505060405180910390f35b348015610cf657600080fd5b50610d2360048036036020811015610d0d57600080fd5b8101908080359060200190929190505050613be9565b6040518082815260200191505060405180910390f35b348015610d4557600080fd5b50610d4e613c03565b005b348015610d5c57600080fd5b50610d65614002565b604051808215151515815260200191505060405180910390f35b348015610d8b57600080fd5b50610db860048036036020811015610da257600080fd5b810190808035906020019092919050505061423a565b005b348015610dc657600080fd5b50610e1360048036036040811015610ddd57600080fd5b8101908080359060200190929190803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050614412565b604051808215151515815260200191505060405180910390f35b348015610e3957600080fd5b50610e4261447d565b6040518082815260200191505060405180910390f35b348015610e6457600080fd5b50610e9160048036036020811015610e7b57600080fd5b8101908080359060200190929190505050614483565b604051808415151515815260200183151515158152602001828152602001935050505060405180910390f35b348015610ec957600080fd5b50610f8360048036036020811015610ee057600080fd5b8101908080359060200190640100000000811115610efd57600080fd5b820183602082011115610f0f57600080fd5b80359060200191846001830284011164010000000083111715610f3157600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f8201169050808301925050505050505091929192905050506144c7565b6040518082815260200191505060405180910390f35b348015610fa557600080fd5b50610fae61465b565b6040518085815260200184815260200183815260200182815260200194505050505060405180910390f35b348015610fe557600080fd5b5061101c60048036036040811015610ffc57600080fd5b810190808035906020019092919080359060200190929190505050614683565b604051808215151515815260200191505060405180910390f35b34801561104257600080fd5b506110836004803603606081101561105957600080fd5b810190808035906020019092919080359060200190929190803590602001909291905050506148e9565b604051808215151515815260200191505060405180910390f35b3480156110a957600080fd5b506110d6600480360360208110156110c057600080fd5b8101908080359060200190929190505050614f7e565b604051808260058111156110e657fe5b60ff16815260200191505060405180910390f35b34801561110657600080fd5b506111336004803603602081101561111d57600080fd5b810190808035906020019092919050505061500f565b005b34801561114157600080fd5b506111786004803603604081101561115857600080fd5b8101908080359060200190929190803590602001909291905050506151e7565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b3480156111c657600080fd5b506111fd600480360360408110156111dd57600080fd5b810190808035906020019092919080359060200190929190505050615339565b604051808215151515815260200191505060405180910390f35b34801561122357600080fd5b506112706004803603604081101561123a57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019092919050505061563f565b60405180878152602001868152602001858152602001848152602001838152602001828152602001965050505050505060405180910390f35b3480156112b557600080fd5b506112f8600480360360208110156112cc57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506156ec565b604051808215151515815260200191505060405180910390f35b34801561131e57600080fd5b506113616004803603602081101561133557600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506157bd565b6040518082815260200191505060405180910390f35b611542600480360360a081101561138d57600080fd5b81019080803590602001906401000000008111156113aa57600080fd5b8201836020820111156113bc57600080fd5b803590602001918460208302840111640100000000831117156113de57600080fd5b9091929391929390803590602001906401000000008111156113ff57600080fd5b82018360208201111561141157600080fd5b8035906020019184602083028401116401000000008311171561143357600080fd5b90919293919293908035906020019064010000000081111561145457600080fd5b82018360208201111561146657600080fd5b8035906020019184600183028401116401000000008311171561148857600080fd5b9091929391929390803590602001906401000000008111156114a957600080fd5b8201836020820111156114bb57600080fd5b803590602001918460208302840111640100000000831117156114dd57600080fd5b9091929391929390803590602001906401000000008111156114fe57600080fd5b82018360208201111561151057600080fd5b8035906020019184600183028401116401000000008311171561153257600080fd5b90919293919293905050506157d5565b6040518082815260200191505060405180910390f35b34801561156457600080fd5b506115916004803603602081101561157b57600080fd5b8101908080359060200190929190505050615b51565b005b34801561159f57600080fd5b506115e2600480360360208110156115b657600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050615d01565b6040518082815260200191505060405180910390f35b34801561160457600080fd5b506116be6004803603602081101561161b57600080fd5b810190808035906020019064010000000081111561163857600080fd5b82018360208201111561164a57600080fd5b8035906020019184600183028401116401000000008311171561166c57600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509192919290505050615f7f565b6040518082815260200191505060405180910390f35b3480156116e057600080fd5b506116e9616113565b6040518080602001828103825283818151815260200191508051906020019060200280838360005b8381101561172c578082015181840152602081019050611711565b505050509050019250505060405180910390f35b34801561174c57600080fd5b506117796004803603602081101561176357600080fd5b810190808035906020019092919050505061616b565b604051808215151515815260200191505060405180910390f35b34801561179f57600080fd5b506117a861619d565b005b3480156117b657600080fd5b506117bf6162d6565b6040518082815260200191505060405180910390f35b3480156117e157600080fd5b506117ea6162e6565b6040518082815260200191505060405180910390f35b34801561180c57600080fd5b506118396004803603602081101561182357600080fd5b81019080803590602001909291905050506162ec565b604051808215151515815260200191505060405180910390f35b34801561185f57600080fd5b50611868616310565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b3480156118b657600080fd5b506118e3600480360360208110156118cd57600080fd5b8101908080359060200190929190505050616336565b005b3480156118f157600080fd5b5061191e6004803603602081101561190857600080fd5b81019080803590602001909291905050506164c3565b6040518082815260200191505060405180910390f35b34801561194057600080fd5b50611949616619565b6040518082815260200191505060405180910390f35b34801561196b57600080fd5b50611a256004803603602081101561198257600080fd5b810190808035906020019064010000000081111561199f57600080fd5b8201836020820111156119b157600080fd5b803590602001918460018302840111640100000000831117156119d357600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509192919290505050616760565b6040518082815260200191505060405180910390f35b348015611a4757600080fd5b50611a506168f4565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b348015611a9e57600080fd5b50611aa761691d565b6040518082815260200191505060405180910390f35b348015611ac957600080fd5b50611ad2616923565b604051808215151515815260200191505060405180910390f35b348015611af857600080fd5b50611b2560048036036020811015611b0f57600080fd5b8101908080359060200190929190505050616981565b005b348015611b3357600080fd5b50611b3c616b2b565b604051808215151515815260200191505060405180910390f35b348015611b6257600080fd5b50611bce60048036036040811015611b7957600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080357bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19169060200190929190505050617216565b6040518082815260200191505060405180910390f35b348015611bf057600080fd5b50611c1d60048036036020811015611c0757600080fd5b8101908080359060200190929190505050617232565b6040518082815260200191505060405180910390f35b348015611c3f57600080fd5b50611c4861734b565b6040518082815260200191505060405180910390f35b348015611c6a57600080fd5b50611c9760048036036020811015611c8157600080fd5b810190808035906020019092919050505061735b565b6040518082815260200191505060405180910390f35b348015611cb957600080fd5b50611ce660048036036020811015611cd057600080fd5b81019080803590602001909291905050506174a4565b005b348015611cf457600080fd5b50611d3760048036036020811015611d0b57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050617662565b005b348015611d4557600080fd5b50611d7260048036036020811015611d5c57600080fd5b8101908080359060200190929190505050617806565b6040518082815260200191505060405180910390f35b348015611d9457600080fd5b50611d9d617827565b6040518082815260200191505060405180910390f35b348015611dbf57600080fd5b50611dec60048036036020811015611dd657600080fd5b8101908080359060200190929190505050617834565b6040518082815260200191505060405180910390f35b348015611e0e57600080fd5b50611e4560048036036040811015611e2557600080fd5b810190808035906020019092919080359060200190929190505050617855565b604051808215151515815260200191505060405180910390f35b348015611e6b57600080fd5b50611f336004803603610180811015611e8357600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190803590602001909291908035906020019092919080359060200190929190803590602001909291908035906020019092919080359060200190929190803590602001909291908035906020019092919080359060200190929190505050617ce8565b005b348015611f4157600080fd5b50611f6e60048036036020811015611f5857600080fd5b8101908080359060200190929190505050617e10565b005b348015611f7c57600080fd5b50611fa960048036036020811015611f9357600080fd5b8101908080359060200190929190505050617fcb565b005b348015611fb757600080fd5b50611fc0618137565b6040518082815260200191505060405180910390f35b348015611fe257600080fd5b50612163600480360360a0811015611ff957600080fd5b810190808035906020019064010000000081111561201657600080fd5b82018360208201111561202857600080fd5b8035906020019184602083028401116401000000008311171561204a57600080fd5b90919293919293908035906020019064010000000081111561206b57600080fd5b82018360208201111561207d57600080fd5b8035906020019184602083028401116401000000008311171561209f57600080fd5b9091929391929390803590602001906401000000008111156120c057600080fd5b8201836020820111156120d257600080fd5b803590602001918460018302840111640100000000831117156120f457600080fd5b90919293919293908035906020019064010000000081111561211557600080fd5b82018360208201111561212757600080fd5b8035906020019184602083028401116401000000008311171561214957600080fd5b909192939192939080359060200190929190505050618147565b6040518082815260200191505060405180910390f35b34801561218557600080fd5b506121c96004803603606081101561219c57600080fd5b810190808035906020019092919080359060200190929190803560ff169060200190929190505050618258565b604051808215151515815260200191505060405180910390f35b3480156121ef57600080fd5b506121f86186c0565b6040518082815260200191505060405180910390f35b34801561221a57600080fd5b506122476004803603602081101561223157600080fd5b81019080803590602001909291905050506186c6565b604051808215151515815260200191505060405180910390f35b34801561226d57600080fd5b5061229a6004803603602081101561228457600080fd5b81019080803590602001909291905050506186ea565b604051808215151515815260200191505060405180910390f35b3480156122c057600080fd5b506122ed600480360360208110156122d757600080fd5b8101908080359060200190929190505050618788565b604051808873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020018781526020018681526020018581526020018060200184815260200183151515158152602001828103825285818151815260200191508051906020019080838360005b83811015612381578082015181840152602081019050612366565b50505050905090810190601f1680156123ae5780820380516001836020036101000a031916815260200191505b509850505050505050505060405180910390f35b3480156123ce57600080fd5b506123d7618863565b6040518085815260200184815260200183815260200182815260200194505050505060405180910390f35b34801561240e57600080fd5b5061243b6004803603602081101561242557600080fd5b81019080803590602001909291905050506188ff565b005b34801561244957600080fd5b5061248c6004803603602081101561246057600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050618a8c565b604051808381526020018281526020019250505060405180910390f35b3480156124b557600080fd5b506124e2600480360360208110156124cc57600080fd5b8101908080359060200190929190505050618b0e565b005b3480156124f057600080fd5b50612671600480360360a081101561250757600080fd5b810190808035906020019064010000000081111561252457600080fd5b82018360208201111561253657600080fd5b8035906020019184602083028401116401000000008311171561255857600080fd5b90919293919293908035906020019064010000000081111561257957600080fd5b82018360208201111561258b57600080fd5b803590602001918460208302840111640100000000831117156125ad57600080fd5b9091929391929390803590602001906401000000008111156125ce57600080fd5b8201836020820111156125e057600080fd5b8035906020019184600183028401116401000000008311171561260257600080fd5b90919293919293908035906020019064010000000081111561262357600080fd5b82018360208201111561263557600080fd5b8035906020019184602083028401116401000000008311171561265757600080fd5b909192939192939080359060200190929190505050618cbe565b005b34801561267f57600080fd5b506126b66004803603604081101561269657600080fd5b8101908080359060200190929190803590602001909291905050506190a5565b604051808481526020018373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561272e578082015181840152602081019050612713565b50505050905090810190601f16801561275b5780820380516001836020036101000a031916815260200191505b5094505050505060405180910390f35b34801561277757600080fd5b5061278061922f565b6040518082815260200191505060405180910390f35b3480156127a257600080fd5b506127ab619235565b6040518082815260200191505060405180910390f35b3480156127cd57600080fd5b506127fa600480360360208110156127e457600080fd5b8101908080359060200190929190505050619371565b60405180848152602001838152602001828152602001935050505060405180910390f35b34801561282a57600080fd5b506128576004803603602081101561284157600080fd5b810190808035906020019092919050505061939e565b6040518082815260200191505060405180910390f35b34801561287957600080fd5b506128d8600480360360c081101561289057600080fd5b810190808035906020019092919080359060200190929190803590602001909291908035906020019092919080359060200190929190803590602001909291905050506193e9565b604051808381526020018281526020019250505060405180910390f35b34801561290157600080fd5b506129776004803603606081101561291857600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080357bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19169060200190929190803590602001909291905050506195fd565b005b34801561298557600080fd5b506129c86004803603602081101561299c57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061993a565b005b3480156129d657600080fd5b50612a23600480360360408110156129ed57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803590602001909291905050506199c0565b005b348015612a3157600080fd5b50612a5e60048036036020811015612a4857600080fd5b8101908080359060200190929190505050619a76565b6040518082815260200191505060405180910390f35b606080601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef6369b317e390916040518263ffffffff1660e01b81526004018082815260200191505060006040518083038186803b158015612ac957600080fd5b505af4158015612add573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052506040811015612b0757600080fd5b8101908080516040519392919084640100000000821115612b2757600080fd5b83820191506020820185811115612b3d57600080fd5b8251866020820283011164010000000082111715612b5a57600080fd5b8083526020830192505050908051906020019060200280838360005b83811015612b91578082015181840152602081019050612b76565b5050505090500160405260200180516040519392919084640100000000821115612bba57600080fd5b83820191506020820185811115612bd057600080fd5b8251866020820283011164010000000082111715612bed57600080fd5b8083526020830192505050908051906020019060200280838360005b83811015612c24578082015181840152602081019050612c09565b50505050905001604052505050915091509091565b612c41616923565b612cb3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b612cbb61ca38565b612cc482619bbf565b9050612ccf81619bdd565b612d24576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602781526020018061ce1b6027913960400191505060405180910390fd5b612d50601960030160405180602001604052908160008201548152505082619bf790919063ffffffff16565b15612dc3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f426173656c696e652071756f72756d20666163746f7220756e6368616e67656481525060200191505060405180910390fd5b806019600301600082015181600001559050507fddfdbe55eaaa70fe2b8bc82a9b0734c25cabe7cb6f1457f9644019f0b5ff91fc826040518082815260200191505060405180910390a15050565b60008060006011600085815260200190815260200160002060000160019054906101000a900460ff166011600086815260200190815260200160002060000160009054906101000a900460ff1660116000878152602001908152602001600020600101549250925092509193909250565b60038060000154908060010154908060020154905083565b600a5481565b60006060600060fa73ffffffffffffffffffffffffffffffffffffffff16844360405160200180838152602001828152602001925050506040516020818303038152906040526040518082805190602001908083835b60208310612f195780518252602082019150602081019050602083039250612ef6565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d8060008114612f79576040519150601f19603f3d011682016040523d82523d6000602084013e612f7e565b606091505b50809350819250505080612fdd576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603d81526020018061cfa8603d913960400191505060405180910390fd5b612fe8826000619c0c565b92505050919050565b600061300e600f6000848152602001908152602001600020619c23565b9050919050565b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600061305a600f60008581526020019081526020016000208484619c33565b905092915050565b600060149054906101000a900460ff1681565b61307d616923565b6130ef576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b6130f761ca38565b61310082619bbf565b905061310b81619bdd565b613160576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602481526020018061d1826024913960400191505060405180910390fd5b61318c601960010160405180602001604052908160008201548152505082619bf790919063ffffffff16565b156131e2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602681526020018061ce8a6026913960400191505060405180910390fd5b806019600101600082015181600001559050507f122a37b609e0f758b6a23c43506cb567017a4d18b21fa91312fb42b44975a5b5826040518082815260200191505060405180910390a15050565b60008060fb73ffffffffffffffffffffffffffffffffffffffff16858585604051602001808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1660601b815260140183805190602001908083835b602083106132b95780518252602082019150602081019050602083039250613296565b6001836020036101000a03801982511681845116808217855250505050505090500182805190602001908083835b6020831061330a57805182526020820191506020810190506020830392506132e7565b6001836020036101000a03801982511681845116808217855250505050505090500193505050506040516020818303038152906040526040518082805190602001908083835b602083106133735780518252602082019150602081019050602083039250613350565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d80600081146133d3576040519150601f19603f3d011682016040523d82523d6000602084013e6133d8565b606091505b505080915050809150509392505050565b6000613406600f6000848152602001908152602001600020619cc6565b9050919050565b6000601060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600201549050919050565b613461616923565b6134d3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600081141561352d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602181526020018061cd2a6021913960400191505060405180910390fd5b6006548114156135a5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260158152602001807f517565756545787069727920756e6368616e676564000000000000000000000081525060200191505060405180910390fd5b806006819055507f4ecbf0bb0701615e2d6f9b0a0996056c959fe359ce76aa7ce06c5f1d57dae4d7816040518082815260200191505060405180910390a150565b60006001806000828254019250508190555060006001549050613607613c03565b6000806136148989619ee6565b9150915061362182619c23565b613630576000935050506138d7565b6003600581111561363d57fe5b81600581111561364957fe5b146136bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260188152602001807f496e636f72726563742070726f706f73616c207374617465000000000000000081525060200191505060405180910390fd5b60006136c6619fc2565b73ffffffffffffffffffffffffffffffffffffffff16636642d594336040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b15801561374257600080fd5b505afa158015613756573d6000803e3d6000fd5b505050506040513d602081101561376c57600080fd5b81019080805190602001909291905050509050600061378961a0bd565b73ffffffffffffffffffffffffffffffffffffffff166361d5c570836040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b15801561380557600080fd5b505afa158015613819573d6000803e3d6000fd5b505050506040513d602081101561382f57600080fd5b81019080805190602001909291905050509050613867876138598a8c61a1b890919063ffffffff16565b61a1b890919063ffffffff16565b8110156138bf576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252604381526020018061d22e6043913960600191505060405180910390fd5b6138ce848c8c858d8d8d61a240565b60019550505050505b600154811461394e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f7265656e7472616e742063616c6c00000000000000000000000000000000000081525060200191505060405180910390fd5b5095945050505050565b6000600360020154905090565b61396d616923565b6139df576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415613a82576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260148152602001807f417070726f7665722063616e6e6f74206265203000000000000000000000000081525060200191505060405180910390fd5b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415613b46576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260128152602001807f417070726f76657220756e6368616e676564000000000000000000000000000081525060200191505060405180910390fd5b80600860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff167fa03757d836cb0b61c0fbba2147f5d51d6071ff3dd5bf6963beb55563d64878e160405160405180910390a250565b6000613bd76162d6565b613be0836164c3565b10159050919050565b6000613bfc82613bf7619235565b61a71f565b9050919050565b613c1a60075460095461a1b890919063ffffffff16565b4210614000576000613c36600a5460126000016002015461a767565b90506060601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef6377b024799091846040518363ffffffff1660e01b8152600401808381526020018281526020019250505060006040518083038186803b158015613c9457600080fd5b505af4158015613ca8573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052506020811015613cd257600080fd5b8101908080516040519392919084640100000000821115613cf257600080fd5b83820191506020820185811115613d0857600080fd5b8251866020820283011164010000000082111715613d2557600080fd5b8083526020830192505050908051906020019060200280838360005b83811015613d5c578082015181840152602081019050613d41565b505050509050016040525050509050600080905060008090505b83811015613fed576000838281518110613d8c57fe5b602002602001015190506000600f60008381526020019081526020016000209050613db68161a780565b15613def57817f88e53c486703527139dfc8d97a1e559d9bd93d3f9d52cda4e06564111e7a264360405160405180910390a25050613fd2565b613e698160010154600d60008460000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461a1b890919063ffffffff16565b600d60008360000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550428160020181905550600060188054905014613f66576000613f01600160188054905061a7a590919063ffffffff16565b905082601760188381548110613f1357fe5b906000526020600020015481548110613f2857fe5b906000526020600020018190555060188181548110613f4357fe5b906000526020600020016000905580601881613f5f919061ca4b565b5050613f93565b60178290806001815401808255809150509060018203906000526020600020016000909192909190915055505b817f3e069fb74dcf5fbc07740b0d40d7f7fc48e9c0ca5dc3d19eb34d2e05d74c5543426040518082815260200191505060405180910390a26001935050505b613fe660018261a1b890919063ffffffff16565b9050613d76565b508015613ffc57426009819055505b5050505b565b600060018060008282540192505081905550600060015490506000600d60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905060008114156140d6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260138152602001807f4e6f7468696e6720746f2077697468647261770000000000000000000000000081525060200191505060405180910390fd5b4781111561414c576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260148152602001807f496e636f6e73697374656e742062616c616e636500000000000000000000000081525060200191505060405180910390fd5b6000600d60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506141ba813373ffffffffffffffffffffffffffffffffffffffff1661a7ef90919063ffffffff16565b60019250506001548114614236576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f7265656e7472616e742063616c6c00000000000000000000000000000000000081525060200191505060405180910390fd5b5090565b614242616923565b6142b4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b6142bc61ca38565b6142c582619bbf565b90506142d081619bdd565b614325576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602781526020018061cd796027913960400191505060405180910390fd5b614351601960000160405180602001604052908160008201548152505082619bf790919063ffffffff16565b156143c4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f50617274696369706174696f6e20626173656c696e6520756e6368616e67656481525060200191505060405180910390fd5b806019600001600082015181600001559050507f51131d2820f04a6b6edd20e22a07d5bf847e265a3906e85256fca7d6043417c5826040518082815260200191505060405180910390a15050565b60006011600084815260200190815260200160002060020160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b600c5481565b60116020528060005260406000206000915090508060000160009054906101000a900460ff16908060000160019054906101000a900460ff16908060010154905083565b60006060600060f473ffffffffffffffffffffffffffffffffffffffff16846040516020018082805190602001908083835b6020831061451c57805182526020820191506020810190506020830392506144f9565b6001836020036101000a0380198251168184511680821785525050505050509050019150506040516020818303038152906040526040518082805190602001908083835b602083106145835780518252602082019150602081019050602083039250614560565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d80600081146145e3576040519150601f19603f3d011682016040523d82523d6000602084013e6145e8565b606091505b50809350819250505080614647576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603881526020018061cf116038913960400191505060405180910390fd5b61465282600061a929565b92505050919050565b6000806000806001600460016000839350829250819150809050935093509350935090919293565b600060018060008282540192505081905550600060015490506146a4613c03565b6000806146b18686619ee6565b9150915060006146c083619c23565b90508015614865576146d18361a9ca565b614743576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260158152602001807f50726f706f73616c206e6f7420617070726f766564000000000000000000000081525060200191505060405180910390fd5b6004600581111561475057fe5b82600581111561475c57fe5b14801561476e575061476d83619cc6565b5b6147c3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602e81526020018061d050602e913960400191505060405180910390fd5b827338afc0dc55415ae27b81c24b5a5fbfe433ebfba863c67e7b4b90916040518263ffffffff1660e01b81526004018082815260200191505060006040518083038186803b15801561481457600080fd5b505af4158015614828573d6000803e3d6000fd5b50505050867f712ae1383f79ac853f8d882153778e0260ef8f03b504e2866e0593e04d2b291f60405160405180910390a261486483888861a9e5565b5b80945050505060015481146148e2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f7265656e7472616e742063616c6c00000000000000000000000000000000000081525060200191505060405180910390fd5b5092915050565b6000600180600082825401925050819055506000600154905061490a613c03565b6149138561ab04565b156149215760009150614eff565b600061492b619fc2565b73ffffffffffffffffffffffffffffffffffffffff16636642d594336040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b1580156149a757600080fd5b505afa1580156149bb573d6000803e3d6000fd5b505050506040513d60208110156149d157600080fd5b810190808051906020019092919050505090506000601060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000209050614a37816000016000015461ab04565b506000614a4261a0bd565b73ffffffffffffffffffffffffffffffffffffffff166330ec70f5846040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015614abe57600080fd5b505afa158015614ad2573d6000803e3d6000fd5b505050506040513d6020811015614ae857600080fd5b8101908080519060200190929190505050905060008111614b54576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602281526020018061d0ee6022913960400191505060405180910390fd5b601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63bfc5163890918a6040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b158015614bae57600080fd5b505af4158015614bc2573d6000803e3d6000fd5b505050506040513d6020811015614bd857600080fd5b8101908080519060200190929190505050614c3e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602981526020018061cf7f6029913960400191505060405180910390fd5b600082600001600001541480614ced5750601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63bfc51638909184600001600001546040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b158015614cb057600080fd5b505af4158015614cc4573d6000803e3d6000fd5b505050506040513d6020811015614cda57600080fd5b8101908080519060200190929190505050155b614d42576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602b81526020018061d203602b913960400191505060405180910390fd5b6000614deb82601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef637577759990918d6040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b158015614da257600080fd5b505af4158015614db6573d6000803e3d6000fd5b505050506040513d6020811015614dcc57600080fd5b810190808051906020019092919050505061a1b890919063ffffffff16565b9050601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63239491ba90918b848c8c6040518663ffffffff1660e01b8152600401808681526020018581526020018481526020018381526020018281526020019550505050505060006040518083038186803b158015614e5f57600080fd5b505af4158015614e73573d6000803e3d6000fd5b5050505060405180604001604052808a8152602001838152508360000160008201518160000155602082015181600101559050508373ffffffffffffffffffffffffffffffffffffffff16897fd19965d25ef670a1e322fbf05475924b7b12d81fd6b96ab718b261782efb3d62846040518082815260200191505060405180910390a360019550505050505b6001548114614f76576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f7265656e7472616e742063616c6c00000000000000000000000000000000000081525060200191505060405180910390fd5b509392505050565b600080821480614f8f5750600b5482115b15614f9d576000905061500a565b6000600f60008481526020019081526020016000209050614fbd836186ea565b15614fe157614fcb8161a780565b614fd6576001614fd9565b60055b91505061500a565b6000614fec8261abd7565b9050614ff8828261ac8e565b6150025780615005565b60055b925050505b919050565b615017616923565b615089576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b61509161ca38565b61509a82619bbf565b90506150a581619bdd565b6150fa576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602781526020018061ceea6027913960400191505060405180910390fd5b615126601960020160405180602001604052908160008201548152505082619bf790919063ffffffff16565b15615199576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f426173656c696e652075706461746520666163746f7220756e6368616e67656481525060200191505060405180910390fd5b806019600201600082015181600001559050507f8dedb4d995dd500718c7c5f6a077fba6153a7ee063da961d9fcab90ff528ac1f826040518082815260200191505060405180910390a15050565b60006060600060fa73ffffffffffffffffffffffffffffffffffffffff16858560405160200180838152602001828152602001925050506040516020818303038152906040526040518082805190602001908083835b60208310615260578051825260208201915060208101905060208303925061523d565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d80600081146152c0576040519150601f19603f3d011682016040523d82523d6000602084013e6152c5565b606091505b50809350819250505080615324576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603681526020018061d01a6036913960400191505060405180910390fd5b61532f826000619c0c565b9250505092915050565b6000600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146153fe576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260178152602001807f6d73672e73656e646572206e6f7420617070726f76657200000000000000000081525060200191505060405180910390fd5b615406613c03565b6000806154138585619ee6565b9150915061542082619c23565b61542f57600092505050615639565b6154388261a9ca565b156154ab576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260198152602001807f50726f706f73616c20616c726561647920617070726f7665640000000000000081525060200191505060405180910390fd5b600360058111156154b857fe5b8160058111156154c457fe5b14806154e65750600460058111156154d857fe5b8160058111156154e457fe5b145b615558576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601d8152602001807f50726f706f73616c206e6f7420696e20636f727265637420737461676500000081525060200191505060405180910390fd5b60018260070160006101000a81548160ff02191690831515021790555061557d61a0bd565b73ffffffffffffffffffffffffffffffffffffffff166330a61d596040518163ffffffff1660e01b815260040160206040518083038186803b1580156155c257600080fd5b505afa1580156155d6573d6000803e3d6000fd5b505050506040513d60208110156155ec57600080fd5b81019080805190602001909291905050508260080181905550847f28ec9e38ba73636ceb2f6c1574136f83bd46284a3c74734b711bf45e12f8d92960405160405180910390a26001925050505b92915050565b6000806000806000806000601060008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206003016000898152602001908152602001600020905080600101548160000160009054906101000a900460ff1660038111156156c157fe5b8260020154836003015484600401548560050154965096509650965096509650509295509295509295565b600080601060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008160000160000154905060008082141580156157535750615752826186ea565b5b80156157655750615763826186c6565b155b90506000600f600085600201548152602001908152602001600020905060006003600581111561579157fe5b61579a8361abd7565b60058111156157a557fe5b14905082806157b15750805b95505050505050919050565b600d6020528060005260406000206000915090505481565b60006157df613c03565b600c54341015615857576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260118152602001807f546f6f20736d616c6c206465706f73697400000000000000000000000000000081525060200191505060405180910390fd5b61586d6001600b5461a1b890919063ffffffff16565b600b819055506000600f6000600b5481526020019081526020016000209050807338afc0dc55415ae27b81c24b5a5fbfe433ebfba8633053123f90918e8e8e8e8e8e8e8e33346040518c63ffffffff1660e01b8152600401808c8152602001806020018060200180602001806020018773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200186815260200185810385528f8f82818152602001925060200280828437600081840152601f19601f82011690508083019250505085810384528d8d82818152602001925060200280828437600081840152601f19601f82011690508083019250505085810383528b8b82818152602001925080828437600081840152601f19601f8201169050808301925050508581038252898982818152602001925060200280828437600081840152601f19601f8201169050808301925050509f5050505050505050505050505050505060006040518083038186803b1580156159f257600080fd5b505af4158015615a06573d6000803e3d6000fd5b50505050615a6184848080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050508261ace590919063ffffffff16565b601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63d7a8acc19091600b546040518363ffffffff1660e01b8152600401808381526020018281526020019250505060006040518083038186803b158015615abd57600080fd5b505af4158015615ad1573d6000803e3d6000fd5b505050503373ffffffffffffffffffffffffffffffffffffffff16600b547f1bfe527f3548d9258c2512b6689f0acfccdd0557d80a53845db25fc57e93d8fe8360060180549050344260405180848152602001838152602001828152602001935050505060405180910390a3600b549150509a9950505050505050505050565b615b59616923565b615bcb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b6000811415615c42576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601e8152602001807f4475726174696f6e206d757374206265206c6172676572207468616e2030000081525060200191505060405180910390fd5b600360020154811415615cbd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260128152602001807f4475726174696f6e20756e6368616e676564000000000000000000000000000081525060200191505060405180910390fd5b806003600201819055507f7819c8059302d1d66abc7fe228ecc02214e0bc5c529956c13717aabefce937d8816040518082815260200191505060405180910390a150565b600080601060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000816000016000015490506000808214158015615d685750615d67826186ea565b5b8015615d7a5750615d78826186c6565b155b90508015615e51576000615d8c61a0bd565b73ffffffffffffffffffffffffffffffffffffffff166330ec70f5876040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015615e0857600080fd5b505afa158015615e1c573d6000803e3d6000fd5b505050506040513d6020811015615e3257600080fd5b8101908080519060200190929190505050905080945050505050615f7a565b600080905060008090505b601780549050811015615f7157600060178281548110615e7857fe5b906000526020600020015490506000600f60008381526020019081526020016000209050600060036005811115615eab57fe5b615eb48361abd7565b6005811115615ebf57fe5b14905080615ecf57505050615f56565b6000886003016000868152602001908152602001600020905083816001015414615efc5750505050615f56565b6000615f2f8260050154615f218460040154856003015461a1b890919063ffffffff16565b61a1b890919063ffffffff16565b9050615f4e8760008314615f435782615f49565b83600201545b61ad5d565b965050505050505b615f6a60018261a1b890919063ffffffff16565b9050615e5c565b50809450505050505b919050565b60006060600060f673ffffffffffffffffffffffffffffffffffffffff16846040516020018082805190602001908083835b60208310615fd45780518252602082019150602081019050602083039250615fb1565b6001836020036101000a0380198251168184511680821785525050505050509050019150506040516020818303038152906040526040518082805190602001908083835b6020831061603b5780518252602082019150602081019050602083039250616018565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d806000811461609b576040519150601f19603f3d011682016040523d82523d6000602084013e6160a0565b606091505b508093508192505050806160ff576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602381526020018061d2716023913960400191505060405180910390fd5b61610a82600061a929565b92505050919050565b6060601780548060200260200160405190810160405280929190818152602001828054801561616157602002820191906000526020600020905b81548152602001906001019080831161614d575b5050505050905090565b600080600f60008481526020019081526020016000209050616195816161908361abd7565b61ac8e565b915050919050565b6161a5616923565b616217576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff166000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a360008060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b60006162e14361939e565b905090565b60075481565b6000616309600f600084815260200190815260200160002061a9ca565b9050919050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b61633e616923565b6163b0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600081141561640a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602681526020018061d07e6026913960400191505060405180910390fd5b600754811415616482576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601a8152602001807f646571756575654672657175656e637920756e6368616e67656400000000000081525060200191505060405180910390fd5b806007819055507f391e82aae76c653cd640ad1b6028e2ee39ca4f29b30152e3d0a9ddd7e1169c34816040518082815260200191505060405180910390a150565b6000806000905060006164d4616619565b905060006164e0619fc2565b905060008090505b8281101561660d5760006164fb82612ea0565b905060008373ffffffffffffffffffffffffffffffffffffffff166393c5c487836040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b15801561657c57600080fd5b505afa158015616590573d6000803e3d6000fd5b505050506040513d60208110156165a657600080fd5b810190808051906020019092919050505090506165c38883614412565b806165d457506165d38882614412565b5b156165f0576165ed60018761a1b890919063ffffffff16565b95505b505061660660018261a1b890919063ffffffff16565b90506164e8565b50829350505050919050565b60006060600060f973ffffffffffffffffffffffffffffffffffffffff1643604051602001808281526020019150506040516020818303038152906040526040518082805190602001908083835b6020831061668a5780518252602082019150602081019050602083039250616667565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d80600081146166ea576040519150601f19603f3d011682016040523d82523d6000602084013e6166ef565b606091505b5080935081925050508061674e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603581526020018061cfe56035913960400191505060405180910390fd5b616759826000619c0c565b9250505090565b60006060600060f773ffffffffffffffffffffffffffffffffffffffff16846040516020018082805190602001908083835b602083106167b55780518252602082019150602081019050602083039250616792565b6001836020036101000a0380198251168184511680821785525050505050509050019150506040516020818303038152906040526040518082805190602001908083835b6020831061681c57805182526020820191506020810190506020830392506167f9565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d806000811461687c576040519150601f19603f3d011682016040523d82523d6000602084013e616881565b606091505b508093508192505050806168e0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603181526020018061d1d26031913960400191505060405180910390fd5b6168eb826000619c0c565b92505050919050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60065481565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1661696561ad77565b73ffffffffffffffffffffffffffffffffffffffff1614905090565b616989616923565b6169fb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b6000811415616a72576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f6d696e4465706f736974206d757374206265206c6172676572207468616e203081525060200191505060405180910390fd5b600c54811415616aea576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260198152602001807f4d696e696d756d206465706f73697420756e6368616e6765640000000000000081525060200191505060405180910390fd5b80600c819055507fc50a7f0bdf88c216b2541b0bdea26f22305460e39ffc672ec1a7501732c5ba81816040518082815260200191505060405180910390a150565b600060018060008282540192505081905550600060015490506000616b4e619fc2565b73ffffffffffffffffffffffffffffffffffffffff16636642d594336040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015616bca57600080fd5b505afa158015616bde573d6000803e3d6000fd5b505050506040513d6020811015616bf457600080fd5b810190808051906020019092919050505090506000601060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008090505b60178054905081101561718a576000826003016000838152602001908152602001600020905060178281548110616c8357fe5b90600052602060002001548160010154148015616cd5575060008160030154141580616cb457506000816004015414155b80616cc457506000816005015414155b80616cd457506000816002015414155b5b1561716e57600080616ceb836001015485619ee6565b9150915060036005811115616cfc57fe5b816005811115616d0857fe5b1415617117576000836002015414616f6f576000600380811115616d2857fe5b8460000160009054906101000a900460ff166003811115616d4557fe5b14616d51576000616d57565b83600201545b9050600060026003811115616d6857fe5b8560000160009054906101000a900460ff166003811115616d8557fe5b14616d91576000616d97565b84600201545b9050600060016003811115616da857fe5b8660000160009054906101000a900460ff166003811115616dc557fe5b14616dd1576000616dd7565b85600201545b9050847338afc0dc55415ae27b81c24b5a5fbfe433ebfba863cd150a6d909185858560008060006040518863ffffffff1660e01b81526004018088815260200187815260200186815260200185815260200184815260200183815260200182815260200197505050505050505060006040518083038186803b158015616e5c57600080fd5b505af4158015616e70573d6000803e3d6000fd5b50505050616e7c61a0bd565b73ffffffffffffffffffffffffffffffffffffffff166330a61d596040518163ffffffff1660e01b815260040160206040518083038186803b158015616ec157600080fd5b505afa158015616ed5573d6000803e3d6000fd5b505050506040513d6020811015616eeb57600080fd5b810190808051906020019092919050505085600801819055508873ffffffffffffffffffffffffffffffffffffffff1686600101547f6791653c96b4863b3768c664e9a03e1094ae334ba9d35862627ceeebd1abcc1f85858560405180848152602001838152602001828152602001935050505060405180910390a3505050617116565b817338afc0dc55415ae27b81c24b5a5fbfe433ebfba863cd150a6d909185600301548660040154876005015460008060006040518863ffffffff1660e01b81526004018088815260200187815260200186815260200185815260200184815260200183815260200182815260200197505050505050505060006040518083038186803b158015616ffe57600080fd5b505af4158015617012573d6000803e3d6000fd5b5050505061701e61a0bd565b73ffffffffffffffffffffffffffffffffffffffff166330a61d596040518163ffffffff1660e01b815260040160206040518083038186803b15801561706357600080fd5b505afa158015617077573d6000803e3d6000fd5b505050506040513d602081101561708d57600080fd5b810190808051906020019092919050505082600801819055508573ffffffffffffffffffffffffffffffffffffffff1683600101547f6791653c96b4863b3768c664e9a03e1094ae334ba9d35862627ceeebd1abcc1f85600301548660040154876005015460405180848152602001838152602001828152602001935050505060405180910390a35b5b846003016000858152602001908152602001600020600080820160006101000a81549060ff021916905560018201600090556002820160009055600382016000905560048201600090556005820160009055505050505b5061718360018261a1b890919063ffffffff16565b9050616c50565b50600081600201819055506001935050506001548114617212576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f7265656e7472616e742063616c6c00000000000000000000000000000000000081525060200191505060405180910390fd5b5090565b600061722a617225848461ad7f565b61afd1565b905092915050565b600061723d826186ea565b6172af576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260138152602001807f50726f706f73616c206e6f74207175657565640000000000000000000000000081525060200191505060405180910390fd5b601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63757775999091846040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b15801561730957600080fd5b505af415801561731d573d6000803e3d6000fd5b505050506040513d602081101561733357600080fd5b81019080805190602001909291905050509050919050565b600061735643613be9565b905090565b60006060600060f973ffffffffffffffffffffffffffffffffffffffff1684604051602001808281526020019150506040516020818303038152906040526040518082805190602001908083835b602083106173cc57805182526020820191506020810190506020830392506173a9565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d806000811461742c576040519150601f19603f3d011682016040523d82523d6000602084013e617431565b606091505b50809350819250505080617490576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602e81526020018061cd4b602e913960400191505060405180910390fd5b61749b826000619c0c565b92505050919050565b806011600082815260200190815260200160002060000160009054906101000a900460ff161561753c576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260178152602001807f686f7466697820616c726561647920657865637574656400000000000000000081525060200191505060405180910390fd5b61754582613bcd565b61759a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602981526020018061d0c56029913960400191505060405180910390fd5b60006175a461734b565b905080601160008581526020019081526020016000206001015410617614576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602681526020018061d1376026913960400191505060405180910390fd5b80601160008581526020019081526020016000206001018190555080837f6f184ec313435b3307a4fe59e2293381f08419a87214464c875a2a247e8af5e060405160405180910390a3505050565b61766a616923565b6176dc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561777f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f43616e6e6f7420726567697374657220746865206e756c6c206164647265737381525060200191505060405180910390fd5b80600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff167f27fe5f0c1c3b1ed427cc63d0f05759ffdecf9aec9e18d31ef366fc8a6cb5dc3b60405160405180910390a250565b6018818154811061781357fe5b906000526020600020016000915090505481565b6000600360010154905090565b6017818154811061784157fe5b906000526020600020016000915090505481565b60006001806000828254019250508190555060006001549050617876613c03565b6000617880619fc2565b73ffffffffffffffffffffffffffffffffffffffff16636642d594336040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b1580156178fc57600080fd5b505afa158015617910573d6000803e3d6000fd5b505050506040513d602081101561792657600080fd5b810190808051906020019092919050505090506000601060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008160000160000154905060008114156179ff576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4163636f756e7420686173206e6f20686973746f726963616c207570766f746581525060200191505060405180910390fd5b617a088161ab04565b50601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63bfc516389091836040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b158015617a6357600080fd5b505af4158015617a77573d6000803e3d6000fd5b505050506040513d6020811015617a8d57600080fd5b810190808051906020019092919050505015617c3157601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63239491ba909183617b708660000160010154601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63757775999091896040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b158015617b2757600080fd5b505af4158015617b3b573d6000803e3d6000fd5b505050506040513d6020811015617b5157600080fd5b810190808051906020019092919050505061a7a590919063ffffffff16565b8b8b6040518663ffffffff1660e01b8152600401808681526020018581526020018481526020018381526020018281526020019550505050505060006040518083038186803b158015617bc257600080fd5b505af4158015617bd6573d6000803e3d6000fd5b505050508273ffffffffffffffffffffffffffffffffffffffff16817f7dc46237a819c9171a9c037ec98928e563892905c4d23373ca0f3f500f4ed11484600001600101546040518082815260200191505060405180910390a35b6040518060400160405280600081526020016000815250826000016000820151816000015560208201518160010155905050600194505050506001548114617ce1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f7265656e7472616e742063616c6c00000000000000000000000000000000000081525060200191505060405180910390fd5b5092915050565b600060149054906101000a900460ff1615617d6b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601c8152602001807f636f6e747261637420616c726561647920696e697469616c697a65640000000081525060200191505060405180910390fd5b6001600060146101000a81548160ff021916908315150217905550617d8f3361afdf565b617d988c617662565b617da18b613965565b617daa8a6188ff565b617db389616981565b617dbc88613459565b617dc587616336565b617dce86618b0e565b617dd785615b51565b617de08461423a565b617de983613075565b617df28261500f565b617dfb81612c39565b42600981905550505050505050505050505050565b806011600082815260200190815260200160002060000160009054906101000a900460ff1615617ea8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260178152602001807f686f7466697820616c726561647920657865637574656400000000000000000081525060200191505060405180910390fd5b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614617f6b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260178152602001807f6d73672e73656e646572206e6f7420617070726f76657200000000000000000081525060200191505060405180910390fd5b60016011600084815260200190815260200160002060000160016101000a81548160ff021916908315150217905550817f36bc158cba244a94dc9b8c08d327e8f7e3c2ab5f1925454c577527466f04851f60405160405180910390a25050565b806011600082815260200190815260200160002060000160009054906101000a900460ff1615618063576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260178152602001807f686f7466697820616c726561647920657865637574656400000000000000000081525060200191505060405180910390fd5b60016011600084815260200190815260200160002060020160003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff021916908315150217905550817ff6d22d0b43a6753880b8f9511b82b86cd0fe349cd580bbe6a25b6dc063ef496f33604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390a25050565b6000601260000160020154905090565b6000898989898989898989604051602001808060200180602001806020018060200186815260200185810385528e8e82818152602001925060200280828437600081840152601f19601f82011690508083019250505085810384528c8c82818152602001925060200280828437600081840152601f19601f82011690508083019250505085810383528a8a82818152602001925080828437600081840152601f19601f8201169050808301925050508581038252888882818152602001925060200280828437600081840152601f19601f8201169050808301925050509d50505050505050505050505050506040516020818303038152906040528051906020012090509998505050505050505050565b60006001806000828254019250508190555060006001549050618279613c03565b6000806182868787619ee6565b9150915061829382619c23565b6182a257600093505050618641565b600360058111156182af57fe5b8160058111156182bb57fe5b1461832e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260188152602001807f496e636f72726563742070726f706f73616c207374617465000000000000000081525060200191505060405180910390fd5b6000600381111561833b57fe5b85600381111561834757fe5b14156183bb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260108152602001807f566f74652076616c756520756e7365740000000000000000000000000000000081525060200191505060405180910390fd5b60006183c5619fc2565b73ffffffffffffffffffffffffffffffffffffffff16636642d594336040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b15801561844157600080fd5b505afa158015618455573d6000803e3d6000fd5b505050506040513d602081101561846b57600080fd5b81019080805190602001909291905050509050600061848861a0bd565b73ffffffffffffffffffffffffffffffffffffffff166361d5c570836040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b15801561850457600080fd5b505afa158015618518573d6000803e3d6000fd5b505050506040513d602081101561852e57600080fd5b8101908080519060200190929190505050905060008114156185b8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260118152602001807f566f74657220776569676874207a65726f00000000000000000000000000000081525060200191505060405180910390fd5b618638848a8a856003808111156185cb57fe5b8c60038111156185d757fe5b146185e35760006185e5565b855b600260038111156185f257fe5b8d60038111156185fe57fe5b1461860a57600061860c565b865b6001600381111561861957fe5b8e600381111561862557fe5b14618631576000618633565b875b61a240565b60019550505050505b60015481146186b8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f7265656e7472616e742063616c6c00000000000000000000000000000000000081525060200191505060405180910390fd5b509392505050565b60095481565b60006186e3600f600084815260200190815260200160002061a780565b9050919050565b6000601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63bfc516389091846040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b15801561874657600080fd5b505af415801561875a573d6000803e3d6000fd5b505050506040513d602081101561877057600080fd5b81019080805190602001909291905050509050919050565b60008060008060606000806187ae600f60008a815260200190815260200160002061b123565b828054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156188435780601f1061881857610100808354040283529160200191618843565b820191906000526020600020905b81548152906001019060200180831161882657829003601f168201915b505050505092509650965096509650965096509650919395979092949650565b60008060008061888b601960000160405180602001604052908160008201548152505061afd1565b6188ad601960010160405180602001604052908160008201548152505061afd1565b6188cf601960020160405180602001604052908160008201548152505061afd1565b6188f1601960030160405180602001604052908160008201548152505061afd1565b935093509350935090919293565b618907616923565b618979576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b60008114156189d3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602c81526020018061cda0602c913960400191505060405180910390fd5b600a54811415618a4b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601d8152602001807f4e756d626572206f662070726f706f73616c7320756e6368616e67656400000081525060200191505060405180910390fd5b80600a819055507f85399b9b2595eb13c392e1638ca77730156cd8d48d4733df4db068e4aa6b93a6816040518082815260200191505060405180910390a150565b600080618a9761ca77565b601060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600001604051806040016040529081600082015481526020016001820154815250509050806000015181602001519250925050915091565b618b16616923565b618b88576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b6000811415618bff576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601e8152602001807f4475726174696f6e206d757374206265206c6172676572207468616e2030000081525060200191505060405180910390fd5b600360010154811415618c7a576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260128152602001807f4475726174696f6e20756e6368616e676564000000000000000000000000000081525060200191505060405180910390fd5b806003600101819055507f90290eb9b27055e686a69fb810bada5381e544d07b8270021da2d355a6c96ed6816040518082815260200191505060405180910390a150565b6000898989898989898989604051602001808060200180602001806020018060200186815260200185810385528e8e82818152602001925060200280828437600081840152601f19601f82011690508083019250505085810384528c8c82818152602001925060200280828437600081840152601f19601f82011690508083019250505085810383528a8a82818152602001925080828437600081840152601f19601f8201169050808301925050508581038252888882818152602001925060200280828437600081840152601f19601f8201169050808301925050509d50505050505050505050505050506040516020818303038152906040528051906020012090506000806000618dd084612e11565b9250925092508115618e4a576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260178152602001807f686f7466697820616c726561647920657865637574656400000000000000000081525060200191505060405180910390fd5b82618ebd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260138152602001807f686f74666978206e6f7420617070726f7665640000000000000000000000000081525060200191505060405180910390fd5b618ec561734b565b8114618f1c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602681526020018061cd046026913960400191505060405180910390fd5b61903a6190358e8e80806020026020016040519081016040528093929190818152602001838360200280828437600081840152601f19601f820116905080830192505050505050508d8d80806020026020016040519081016040528093929190818152602001838360200280828437600081840152601f19601f820116905080830192505050505050508c8c8080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050508b8b80806020026020016040519081016040528093929190818152602001838360200280828437600081840152601f19601f8201169050808301925050505050505033600061b19c565b61b3c5565b60016011600086815260200190815260200160002060000160006101000a81548160ff021916908315150217905550837f708a7934acb657a77a617b1fcd5f6d7d9ad592b72934841bff01acefd10f9b6360405160405180910390a250505050505050505050505050565b6000806060600f60008681526020019081526020016000207338afc0dc55415ae27b81c24b5a5fbfe433ebfba863e6a5192f9091866040518363ffffffff1660e01b8152600401808381526020018281526020019250505060006040518083038186803b15801561911557600080fd5b505af4158015619129573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f82011682018060405250606081101561915357600080fd5b8101908080519060200190929190805190602001909291908051604051939291908464010000000082111561918757600080fd5b8382019150602082018581111561919d57600080fd5b82518660018202830111640100000000821117156191ba57600080fd5b8083526020830192505050908051906020019080838360005b838110156191ee5780820151818401526020810190506191d3565b50505050905090810190601f16801561921b5780820380516001836020036101000a031916815260200191505b506040525050509250925092509250925092565b600b5481565b60006060600060f873ffffffffffffffffffffffffffffffffffffffff166040516020016040516020818303038152906040526040518082805190602001908083835b6020831061929b5780518252602082019150602081019050602083039250619278565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d80600081146192fb576040519150601f19603f3d011682016040523d82523d6000602084013e619300565b606091505b5080935081925050508061935f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602581526020018061d15d6025913960400191505060405180910390fd5b61936a826000619c0c565b9250505090565b6000806000619391600f600086815260200190815260200160002061b3d5565b9250925092509193909250565b60006193e260036193d460026193c660026193b88861735b565b61b3ff90919063ffffffff16565b61a1b890919063ffffffff16565b61b48590919063ffffffff16565b9050919050565b600080600087141580156193fe575060008514155b619470576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260158152602001807f612064656e6f6d696e61746f72206973207a65726f000000000000000000000081525060200191505060405180910390fd5b6000806000606060fc73ffffffffffffffffffffffffffffffffffffffff168c8c8c8c8c8c6040516020018087815260200186815260200185815260200184815260200183815260200182815260200196505050505050506040516020818303038152906040526040518082805190602001908083835b6020831061950a57805182526020820191506020810190506020830392506194e7565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d806000811461956a576040519150601f19603f3d011682016040523d82523d6000602084013e61956f565b606091505b508092508193505050816195ce576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602781526020018061d1106027913960400191505060405180910390fd5b6195d9816000619c0c565b93506195e6816020619c0c565b925083839550955050505050965096945050505050565b619605616923565b619677576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561971a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601a8152602001807f44657374696e6174696f6e2063616e6e6f74206265207a65726f00000000000081525060200191505060405180910390fd5b6969e10de76676d080000081118015619742575061973e61973961b4cf565b61afd1565b8111155b619797576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252604881526020018061ce426048913960600191505060405180910390fd5b600060e01b827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916141561981f576197cb81619bbf565b600e60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600001600082015181600001559050506198c7565b61982881619bbf565b600e60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206001016000847bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001908152602001600020600082015181600001559050505b817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168373ffffffffffffffffffffffffffffffffffffffff167f60c5b4756af49d7b071b00dbf0f87af605cce11896ecd3b760d19f0f9d3fbcef836040518082815260200191505060405180910390a3505050565b619942616923565b6199b4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b6199bd8161afdf565b50565b6199c861a0bd565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614619a68576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260198152602001807f6d73672e73656e646572206e6f74206c6f636b6564476f6c640000000000000081525060200191505060405180910390fd5b619a72828261b4f5565b5050565b60006060600060f573ffffffffffffffffffffffffffffffffffffffff1684604051602001808281526020019150506040516020818303038152906040526040518082805190602001908083835b60208310619ae75780518252602082019150602081019050602083039250619ac4565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855afa9150503d8060008114619b47576040519150601f19603f3d011682016040523d82523d6000602084013e619b4c565b606091505b50809350819250505080619bab576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602c81526020018061d1a6602c913960400191505060405180910390fd5b619bb682600061a929565b92505050919050565b619bc761ca38565b6040518060200160405280838152509050919050565b6000619bf082619beb61b4cf565b61b8ec565b9050919050565b60008160000151836000015114905092915050565b6000619c18838361a929565b60001c905092915050565b6000808260020154119050919050565b60006017805490508210619c92576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602b81526020018061d294602b913960400191505060405180910390fd5b619c9b84619c23565b8015619cbd57508260178381548110619cb057fe5b9060005260206000200154145b90509392505050565b6000619cd061ca38565b619d27619d186019600301604051806020016040529081600082015481525050601960000160405180602001604052908160008201548152505061b90290919063ffffffff16565b8461bd6190919063ffffffff16565b9050600083600601805490501415619d6a57619d4161ca38565b619d4c60008061ad7f565b9050619d61818361be5090919063ffffffff16565b92505050619ee1565b60008090505b8360060180549050811015619eda576000619e42856006018381548110619d9357fe5b90600052602060002090600302016002018054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015619e385780601f10619e0d57610100808354040283529160200191619e38565b820191906000526020600020905b815481529060010190602001808311619e1b57829003601f168201915b505050505061be65565b9050619e4c61ca38565b619e96866006018481548110619e5e57fe5b906000526020600020906003020160010160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff168361ad7f565b9050619eab818561b8ec90919063ffffffff16565b15619ebd576000945050505050619ee1565b5050619ed360018261a1b890919063ffffffff16565b9050619d70565b5060019150505b919050565b6000806000600f60008681526020019081526020016000209050619f0b818686619c33565b619f7d576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260158152602001807f50726f706f73616c206e6f74206465717565756564000000000000000000000081525060200191505060405180910390fd5b6000619f888261abd7565b9050619f94828261ac8e565b15619fb257619fa482878761a9e5565b816005935093505050619fbb565b81819350935050505b9250929050565b6000600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663dcf0aaed60405160200180807f4163636f756e74730000000000000000000000000000000000000000000000008152506008019050604051602081830303815290604052805190602001206040518263ffffffff1660e01b81526004018082815260200191505060206040518083038186803b15801561a07d57600080fd5b505afa15801561a091573d6000803e3d6000fd5b505050506040513d602081101561a0a757600080fd5b8101908080519060200190929190505050905090565b6000600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663dcf0aaed60405160200180807f4c6f636b6564476f6c6400000000000000000000000000000000000000000000815250600a019050604051602081830303815290604052805190602001206040518263ffffffff1660e01b81526004018082815260200191505060206040518083038186803b15801561a17857600080fd5b505afa15801561a18c573d6000803e3d6000fd5b505050506040513d602081101561a1a257600080fd5b8101908080519060200190929190505050905090565b60008082840190508381101561a236576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f536166654d6174683a206164646974696f6e206f766572666c6f77000000000081525060200191505060405180910390fd5b8091505092915050565b6000601060008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000209050600081600301600088815260200190815260200160002090508781600101541461a34757887338afc0dc55415ae27b81c24b5a5fbfe433ebfba863cd150a6d909160008060008a8a8a6040518863ffffffff1660e01b81526004018088815260200187815260200186815260200185815260200184815260200183815260200182815260200197505050505050505060006040518083038186803b15801561a32a57600080fd5b505af415801561a33e573d6000803e3d6000fd5b5050505061a548565b600081600201541461a4a157887338afc0dc55415ae27b81c24b5a5fbfe433ebfba863cd150a6d909160038081111561a37c57fe5b8460000160009054906101000a900460ff16600381111561a39957fe5b1461a3a557600061a3ab565b83600201545b6002600381111561a3b857fe5b8560000160009054906101000a900460ff16600381111561a3d557fe5b1461a3e157600061a3e7565b84600201545b6001600381111561a3f457fe5b8660000160009054906101000a900460ff16600381111561a41157fe5b1461a41d57600061a423565b85600201545b8a8a8a6040518863ffffffff1660e01b81526004018088815260200187815260200186815260200185815260200184815260200183815260200182815260200197505050505050505060006040518083038186803b15801561a48457600080fd5b505af415801561a498573d6000803e3d6000fd5b5050505061a547565b887338afc0dc55415ae27b81c24b5a5fbfe433ebfba863cd150a6d90918360030154846004015485600501548a8a8a6040518863ffffffff1660e01b81526004018088815260200187815260200186815260200185815260200184815260200183815260200182815260200197505050505050505060006040518083038186803b15801561a52e57600080fd5b505af415801561a542573d6000803e3d6000fd5b505050505b5b61a55061a0bd565b73ffffffffffffffffffffffffffffffffffffffff166330a61d596040518163ffffffff1660e01b815260040160206040518083038186803b15801561a59557600080fd5b505afa15801561a5a9573d6000803e3d6000fd5b505050506040513d602081101561a5bf57600080fd5b810190808051906020019092919050505089600801819055506040518060c001604052806000600381111561a5f057fe5b8152602001898152602001600081526020018681526020018581526020018481525082600301600089815260200190815260200160002060008201518160000160006101000a81548160ff0219169083600381111561a64b57fe5b02179055506020820151816001015560408201518160020155606082015181600301556080820151816004015560a08201518160050155905050600f600083600201548152602001908152602001600020600201548960020154111561a6b5578782600201819055505b8573ffffffffffffffffffffffffffffffffffffffff16887f683ebddc94b5b0a7dae3d1b6c168ad05684fcfd831b24ecb5ea9ecdf5524d02887878760405180848152602001838152602001828152602001935050505060405180910390a3505050505050505050565b60008082848161a72b57fe5b049050600083858161a73957fe5b06141561a749578091505061a761565b61a75d60018261a1b890919063ffffffff16565b9150505b92915050565b600081831061a776578161a778565b825b905092915050565b600061a79b600654836002015461a1b890919063ffffffff16565b4210159050919050565b600061a7e783836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f77000081525061bfc2565b905092915050565b8047101561a865576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601d8152602001807f416464726573733a20696e73756666696369656e742062616c616e636500000081525060200191505060405180910390fd5b60008273ffffffffffffffffffffffffffffffffffffffff168260405180600001905060006040518083038185875af1925050503d806000811461a8c5576040519150601f19603f3d011682016040523d82523d6000602084013e61a8ca565b606091505b505090508061a924576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603a81526020018061ceb0603a913960400191505060405180910390fd5b505050565b600061a93f60208361a1b890919063ffffffff16565b8351101561a9b5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260148152602001807f736c6963696e67206f7574206f662072616e676500000000000000000000000081525060200191505060405180910390fd5b60006020830184015190508091505092915050565b60008160070160009054906101000a900460ff169050919050565b61a9ee8361a9ca565b801561a9ff57506000836008015414155b1561aa0e5761aa0d8361c082565b5b60006017828154811061aa1d57fe5b90600052602060002001819055506018819080600181540180825580915050906001820390600052602060002001600090919290919091505550600f6000838152602001908152602001600020600080820160006101000a81549073ffffffffffffffffffffffffffffffffffffffff0219169055600182016000905560028201600090556003820160008082016000905560018201600090556002820160009055505060068201600061aad1919061ca91565b6007820160006101000a81549060ff0219169055600882016000905560098201600061aafd919061cab5565b5050505050565b600061ab0f826186ea565b801561ab20575061ab1f826186c6565b5b1561abcd57601273411b40a81a07fcd3542ce5b3d7e215178c4ca2ef63eed5f7be9091846040518363ffffffff1660e01b8152600401808381526020018281526020019250505060006040518083038186803b15801561ab7f57600080fd5b505af415801561ab93573d6000803e3d6000fd5b50505050817f88e53c486703527139dfc8d97a1e559d9bd93d3f9d52cda4e06564111e7a264360405160405180910390a26001905061abd2565b600090505b919050565b60008061ac0d60036002015461abff600360010154866002015461a1b890919063ffffffff16565b61a1b890919063ffffffff16565b905080421015801561ac4957506000836006018054905014158061ac37575061ac358361a9ca565b155b8061ac48575061ac4683619cc6565b155b5b1561ac5857600591505061ac89565b61ac706003600201548261a7a590919063ffffffff16565b905080421061ac8357600491505061ac89565b60039150505b919050565b60006004600581111561ac9d57fe5b82600581111561aca957fe5b118061acdd57506003600581111561acbd57fe5b82600581111561acc957fe5b11801561acdc575061acda83619cc6565b155b5b905092915050565b60008151141561ad40576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602981526020018061cdf26029913960400191505060405180910390fd5b8082600901908051906020019061ad5892919061cafd565b505050565b60008183101561ad6d578161ad6f565b825b905092915050565b600033905090565b61ad8761ca38565b61ad8f61ca38565b61ada26969e10de76676d0800000619bbf565b9050600061ae54600e60008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206001016000867bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190815260200160002060405180602001604052908160008201548152505061afd1565b1461af0657600e60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206001016000847bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001908152602001600020604051806020016040529081600082015481525050905061afc7565b600061af67600e60008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060000160405180602001604052908160008201548152505061afd1565b1461afc657600e60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060000160405180602001604052908160008201548152505090505b5b8091505092915050565b600081600001519050919050565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561b065576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602681526020018061cdcc6026913960400191505060405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff166000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060008060008060008760000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16886001015489600201548a600601805490508b6009018c600801548d60070160009054906101000a900460ff168292509650965096509650965096509650919395979092949650565b61b1a461cb7d565b8551875114801561b1b6575083518651145b61b228576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260158152602001807f4172726179206c656e677468206d69736d61746368000000000000000000000081525060200191505060405180910390fd5b60008751905061b23661cb7d565b84816000019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff1681525050838160200181815250504281604001818152505060008090508260405190808252806020026020018201604052801561b2c157816020015b61b2ae61cbe0565b81526020019060019003908161b2a65790505b50826080018190525060008090505b8381101561b3b45760405180606001604052808c838151811061b2ef57fe5b602002602001015181526020018b838151811061b30857fe5b602002602001015173ffffffffffffffffffffffffffffffffffffffff16815260200161b353848b858151811061b33b57fe5b60200260200101518d61c2189092919063ffffffff16565b8152508360800151828151811061b36657fe5b602002602001018190525061b39788828151811061b38057fe5b60200260200101518361a1b890919063ffffffff16565b915061b3ad60018261a1b890919063ffffffff16565b905061b2d0565b508193505050509695505050505050565b61b3d2816080015161c2a4565b50565b60008060008360030160000154846003016001015485600301600201549250925092509193909250565b60008083141561b412576000905061b47f565b600082840290508284828161b42357fe5b041461b47a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602181526020018061d0a46021913960400191505060405180910390fd5b809150505b92915050565b600061b4c783836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f00000000000081525061c3ad565b905092915050565b61b4d761ca38565b604051806020016040528069d3c21bcecceda1000000815250905090565b6000601060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008090505b60178054905081101561b8e65760006017828154811061b55a57fe5b906000526020600020015490506000600f6000838152602001908152602001600020905060006003600581111561b58d57fe5b61b5968361abd7565b600581111561b5a157fe5b1490508061b5b15750505061b8cb565b600085600301600086815260200190815260200160002090508381600101541461b63257856003016000868152602001908152602001600020600080820160006101000a81549060ff02191690556001820160009055600282016000905560038201600090556004820160009055600582016000905550505050505061b8cb565b600061b665826005015461b6578460040154856003015461a1b890919063ffffffff16565b61a1b890919063ffffffff16565b90508781111561b8c557600061b684898361a7a590919063ffffffff16565b9050600061b6978285600501548561c473565b9050600061b6aa8386600301548661c473565b9050600061b6bd8487600401548761c473565b9050600061b6e68261b6d8858761a1b890919063ffffffff16565b61a1b890919063ffffffff16565b9050600061b70184896003015461a7a590919063ffffffff16565b9050600061b71c848a6004015461a7a590919063ffffffff16565b9050600061b737878b6005015461a7a590919063ffffffff16565b90508784101561b7fc57600061b756858a61a7a590919063ffffffff16565b9050600061b764828661a767565b905061b779818661a7a590919063ffffffff16565b945061b78e818361a7a590919063ffffffff16565b91506000821461b7cf5761b7a2828561a767565b905061b7b7818561a7a590919063ffffffff16565b935061b7cc818361a7a590919063ffffffff16565b91505b6000821461b7f95761b7e1828461a767565b905061b7f6818461a7a590919063ffffffff16565b92505b50505b8b7338afc0dc55415ae27b81c24b5a5fbfe433ebfba863cd150a6d90918c600301548d600401548e600501548888886040518863ffffffff1660e01b81526004018088815260200187815260200186815260200185815260200184815260200183815260200182815260200197505050505050505060006040518083038186803b15801561b88957600080fd5b505af415801561b89d573d6000803e3d6000fd5b50505050808a60050181905550828a60030181905550818a6004018190555050505050505050505b50505050505b61b8df60018261a1b890919063ffffffff16565b905061b53e565b50505050565b6000816000015183600001511115905092915050565b61b90a61ca38565b60008360000151148061b921575060008260000151145b1561b93d5760405180602001604052806000815250905061bd5b565b69d3c21bcecceda10000008260000151141561b95b5782905061bd5b565b69d3c21bcecceda10000008360000151141561b9795781905061bd5b565b600069d3c21bcecceda100000061b98f8561c4aa565b600001518161b99a57fe5b049050600061b9a88561c4e1565b600001519050600069d3c21bcecceda100000061b9c48661c4aa565b600001518161b9cf57fe5b049050600061b9dd8661c4e1565b600001519050600082850290506000851461ba71578285828161b9fc57fe5b041461ba70576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260168152602001807f6f766572666c6f7720783179312064657465637465640000000000000000000081525060200191505060405180910390fd5b5b600069d3c21bcecceda1000000820290506000821461bb135769d3c21bcecceda100000082828161ba9e57fe5b041461bb12576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f6f766572666c6f772078317931202a206669786564312064657465637465640081525060200191505060405180910390fd5b5b809150600084860290506000861461bba4578486828161bb2f57fe5b041461bba3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260168152602001807f6f766572666c6f7720783279312064657465637465640000000000000000000081525060200191505060405180910390fd5b5b600084880290506000881461bc32578488828161bbbd57fe5b041461bc31576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260168152602001807f6f766572666c6f7720783179322064657465637465640000000000000000000081525060200191505060405180910390fd5b5b61bc3a61c51e565b878161bc4257fe5b04965061bc4d61c51e565b858161bc5557fe5b049450600085880290506000881461bce6578588828161bc7157fe5b041461bce5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260168152602001807f6f766572666c6f7720783279322064657465637465640000000000000000000081525060200191505060405180910390fd5b5b61bcee61ca38565b604051806020016040528087815250905061bd178160405180602001604052808781525061c52b565b905061bd318160405180602001604052808681525061c52b565b905061bd4b8160405180602001604052808581525061c52b565b9050809a50505050505050505050505b92915050565b61bd6961ca38565b600083600301600001549050600081141561bd905761bd88600061c5d4565b91505061be4a565b600084600301600101549050600061bdca866003016002015461bdbc848661a1b890919063ffffffff16565b61a1b890919063ffffffff16565b9050600061bdf561bdf061bde1896008015461c5d4565b8861b90290919063ffffffff16565b61c65e565b90508181111561be275761be2461be15838361a7a590919063ffffffff16565b8461a1b890919063ffffffff16565b92505b61be438461be3e858761a1b890919063ffffffff16565b61c67f565b9450505050505b92915050565b60008160000151836000015111905092915050565b600060188260038151811061be7657fe5b602001015160f81c60f81b7effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916901c60108360028151811061bed357fe5b602001015160f81c60f81b7effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916901c60088460018151811061bf3057fe5b602001015160f81c60f81b7effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916901c8460008151811061bf8b57fe5b602001015160f81c60f81b7effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff19161717179050919050565b600083831115829061c06f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561c03457808201518184015260208101905061c019565b50505050905090810190601f16801561c0615780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5060008385039050809150509392505050565b61c08a61ca38565b61c0938261c6c1565b905061c09d61ca38565b61c0c960196002016040518060200160405290816000820154815250508361b90290919063ffffffff16565b905061c0d361ca38565b61c13161c109601960020160405180602001604052908160008201548152505061c0fb61b4cf565b61c71d90919063ffffffff16565b601960000160405180602001604052908160008201548152505061b90290919063ffffffff16565b905061c146818361c52b90919063ffffffff16565b60196000016000820151816000015590505061c19d6019600101604051806020016040529081600082015481525050601960000160405180602001604052908160008201548152505061c7c490919063ffffffff16565b1561c1ba5760196001016019600001600082015481600001559050505b7f51131d2820f04a6b6edd20e22a07d5bf847e265a3906e85256fca7d6043417c561c1fd601960000160405180602001604052908160008201548152505061afd1565b6040518082815260200191505060405180910390a150505050565b60608183018451101561c22a57600080fd5b606082156000811461c2475760405191506020820160405261c298565b6040519150601f8416801560200281840101858101878315602002848b0101015b8183101561c285578051835260208301925060208101905061c268565b50868552601f19601f8301166040525050505b50809150509392505050565b60008090505b815181101561c3a95761c31c82828151811061c2c257fe5b60200260200101516020015183838151811061c2da57fe5b60200260200101516000015184848151811061c2f257fe5b6020026020010151604001515185858151811061c30b57fe5b60200260200101516040015161c7d9565b61c38e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260198152602001807f50726f706f73616c20657865637574696f6e206661696c65640000000000000081525060200191505060405180910390fd5b61c3a260018261a1b890919063ffffffff16565b905061c2aa565b5050565b6000808311829061c459576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561c41e57808201518184015260208101905061c403565b50505050905090810190601f16801561c44b5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b50600083858161c46557fe5b049050809150509392505050565b600061c4a161c49c61c485858561c67f565b61c48e8761c5d4565b61b90290919063ffffffff16565b61c65e565b90509392505050565b61c4b261ca38565b604051806020016040528069d3c21bcecceda10000008085600001518161c4d557fe5b04028152509050919050565b61c4e961ca38565b604051806020016040528069d3c21bcecceda10000008085600001518161c50c57fe5b04028460000151038152509050919050565b600064e8d4a51000905090565b61c53361ca38565b600082600001518460000151019050836000015181101561c5bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260158152602001807f616464206f766572666c6f77206465746563746564000000000000000000000081525060200191505060405180910390fd5b60405180602001604052808281525091505092915050565b61c5dc61ca38565b61c5e461c885565b82111561c63c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603681526020018061cf496036913960400191505060405180910390fd5b604051806020016040528069d3c21bcecceda100000084028152509050919050565b600069d3c21bcecceda100000082600001518161c67757fe5b049050919050565b61c68761ca38565b61c68f61ca38565b61c6988461c5d4565b905061c6a261ca38565b61c6ab8461c5d4565b905061c6b7828261c8a4565b9250505092915050565b61c6c961ca38565b600061c705836003016002015461c6f78560030160010154866003016000015461a1b890919063ffffffff16565b61a1b890919063ffffffff16565b905061c71581846008015461c67f565b915050919050565b61c72561ca38565b81600001518360000151101561c7a3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f737562737472616374696f6e20756e646572666c6f772064657465637465640081525060200191505060405180910390fd5b60405180602001604052808360000151856000015103815250905092915050565b60008160000151836000015110905092915050565b600080600084111561c8615761c7ee8661c9ed565b61c860576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260188152602001807f496e76616c696420636f6e74726163742061646472657373000000000000000081525060200191505060405180910390fd5b5b6040516020840160008287838a8c6187965a03f19250505080915050949350505050565b60007601357c299a88ea76a58924d52ce4f26a85af186c2b9e74905090565b61c8ac61ca38565b60008260000151141561c927576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260118152602001807f63616e277420646976696465206279203000000000000000000000000000000081525060200191505060405180910390fd5b600069d3c21bcecceda10000008460000151029050836000015169d3c21bcecceda1000000828161c95457fe5b041461c9c8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260128152602001807f6f766572666c6f7720617420646976696465000000000000000000000000000081525060200191505060405180910390fd5b60405180602001604052808460000151838161c9e057fe5b0481525091505092915050565b60008060007fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060001b9050833f915080821415801561ca2f57506000801b8214155b92505050919050565b6040518060200160405280600081525090565b81548183558181111561ca725781836000526020600020918201910161ca71919061cc17565b5b505050565b604051806040016040528060008152602001600081525090565b508054600082556003029060005260206000209081019061cab2919061cc3c565b50565b50805460018160011615610100020316600290046000825580601f1061cadb575061cafa565b601f01602090049060005260206000209081019061caf9919061cc17565b5b50565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061cb3e57805160ff191683800117855561cb6c565b8280016001018555821561cb6c579182015b8281111561cb6b57825182559160200191906001019061cb50565b5b50905061cb79919061cc17565b5090565b604051806101000160405280600073ffffffffffffffffffffffffffffffffffffffff168152602001600081526020016000815260200161cbbc61cc9a565b81526020016060815260200160001515815260200160008152602001606081525090565b604051806060016040528060008152602001600073ffffffffffffffffffffffffffffffffffffffff168152602001606081525090565b61cc3991905b8082111561cc3557600081600090555060010161cc1d565b5090565b90565b61cc9791905b8082111561cc93576000808201600090556001820160006101000a81549073ffffffffffffffffffffffffffffffffffffffff021916905560028201600061cc8a919061ccbb565b5060030161cc42565b5090565b90565b60405180606001604052806000815260200160008152602001600081525090565b50805460018160011615610100020316600290046000825580601f1061cce1575061cd00565b601f01602090049060005260206000209081019061ccff919061cc17565b5b5056fe686f74666978206d75737420626520707265706172656420666f7220746869732065706f63685175657565457870697279206d757374206265206c6172676572207468616e20306572726f722063616c6c696e67206e756d62657256616c696461746f7273496e53657420707265636f6d70696c6550617274696369706174696f6e20626173656c696e652067726561746572207468616e206f6e654e756d626572206f662070726f706f73616c73206d757374206265206c6172676572207468616e207a65726f4f776e61626c653a206e6577206f776e657220697320746865207a65726f20616464726573734465736372697074696f6e2075726c206d7573742068617665206e6f6e2d7a65726f206c656e677468426173656c696e652071756f72756d20666163746f722067726561746572207468616e206f6e655468726573686f6c642068617320746f2062652067726561746572207468616e206d616a6f7269747920616e64206e6f742067726561746572207468616e20756e616e696d69747950617274696369706174696f6e20626173656c696e6520666c6f6f7220756e6368616e676564416464726573733a20756e61626c6520746f2073656e642076616c75652c20726563697069656e74206d61792068617665207265766572746564426173656c696e652075706461746520666163746f722067726561746572207468616e206f6e656572726f722063616c6c696e672067657456657269666965645365616c4269746d617046726f6d48656164657220707265636f6d70696c6563616e277420637265617465206669786964697479206e756d626572206c6172676572207468616e206d61784e65774669786564282963616e6e6f74207570766f746520612070726f706f73616c206e6f7420696e207468652071756575656572726f722063616c6c696e672076616c696461746f725369676e65724164647265737346726f6d43757272656e7453657420707265636f6d70696c656572726f722063616c6c696e67206e756d62657256616c696461746f7273496e43757272656e7453657420707265636f6d70696c656572726f722063616c6c696e672076616c696461746f725369676e65724164647265737346726f6d53657420707265636f6d70696c6550726f706f73616c206e6f7420696e20657865637574696f6e207374616765206f72206e6f742070617373696e67646571756575654672657175656e6379206d757374206265206c6172676572207468616e2030536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f77686f74666978206e6f742077686974656c69737465642062792032662b312076616c696461746f727363616e6e6f74207570766f746520776974686f7574206c6f636b696e6720676f6c646572726f722063616c6c696e67206672616374696f6e4d756c45787020707265636f6d70696c65686f7466697820616c726561647920707265706172656420666f7220746869732065706f63686572726f722063616c6c696e672067657445706f636853697a6520707265636f6d70696c6550617274696369706174696f6e20666c6f6f722067726561746572207468616e206f6e656572726f722063616c6c696e6720676574506172656e745365616c4269746d617020707265636f6d70696c656572726f722063616c6c696e6720676574426c6f636b4e756d62657246726f6d48656164657220707265636f6d70696c6563616e6e6f74207570766f7465206d6f7265207468616e206f6e65207175657565642070726f706f73616c566f74657220646f65736e2774206861766520656e6f756768206c6f636b65642043656c6f2028666f726d65726c79206b6e6f776e2061732043656c6f20476f6c64296572726f722063616c6c696e67206861736848656164657220707265636f6d70696c6550726f766964656420696e6465782067726561746572207468616e2064657175657565206c656e6774682ea265627a7a72315820f26992a3c6f7f433a05fcbc7b6064c59c4025dafee70c37f843f88e8d2be6c7164736f6c634300050d00320000000000000000000000000000000000000000000000000000000000000000

Deployed ByteCode

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