function init(address sender) internal {
  _addAdmin(sender);
}

function _returnAsset(
  address asset,
  address to,
  uint256 value
) internal {
  if (asset == address(0x0)) {
    to.transfer(value);
  } else {
    Erc20 token = Erc20(asset);
    require(token.transfer(to, value));
  }
}

function _withdrawAsset(address asset, uint256 value) internal {
  require(
    availableToWithdraw(asset) >= value,
    "Cannot withdraw more than is unlocked"
  );
  withdrawnAssets[asset] = withdrawnAssets[asset].add(value);
  emit Withdraw(asset, msg.sender, value);
}

function _tokenPayment(
  address from,
  uint256 value,
  address tokenAddress,
  bytes32 transactionHash
) internal {
  uint256 tokenPrice = getTokenPrice(tokenAddress);
  uint256 give = getTokenTotal(tokenAddress, value);

  emit Payment(tokenAddress, from, value, tokenPrice, transactionHash);
  _increase(from, give, tokenAddress, value);
  _assetPaid(tokenAddress, from, value);
}

function _assetPaid(
  address asset,
  address account,
  uint256 value
) internal {
  User storage user = users[account];
  // No reason to record the asset if it's 0 value
  if (value > 0) {
    uint256 paid = user.assets[asset];

    if (paid > 0) {
      user.assets[asset] = paid.add(value);
    } else {
      user.assetList.push(asset);
      user.assets[asset] = value;
    }

    if (user.kycVerified) {
      unlockedAssets[asset] = unlockedAssets[asset].add(value);
      emit AssetUnlocked(asset, account, value);
    }
  }
}

function _assetRefunded(
  address asset,
  address account,
  uint256 value
) internal {
  User storage user = users[account];
  user.assets[asset] = user.assets[asset].sub(value);

  if (user.kycVerified) {
    unlockedAssets[asset] = unlockedAssets[asset].sub(value);
    emit AssetLocked(asset, account, value);
    require(
      unlockedAssets[asset] >= withdrawnAssets[asset],
      "Cannot refund assets to KYC Verified users without unlocked assets available"
    );
  }

  emit Refund(asset, account, value);
}

function _setTokenPrice(address tokenAddress, uint256 tokenPrice) internal {
  require(tokenPrice > 0, "Token price must be higher than 0");

  Token storage token = tokens[tokenAddress];
  if (token.price > 0) {
    token.price = tokenPrice;
  } else {
    tokenList.push(tokenAddress);
    token.price = tokenPrice;
    token.index = tokenList.length - 1;
  }
  emit TokenPriceSet(tokenAddress, tokenPrice);
}

function _increase(
  address account,
  uint256 value,
  address asset,
  uint256 assetValue
) internal {
  User storage user = users[account];
  if (limited) {
    remainingSupply = remainingSupply.sub(value);
  } else {
    totalTokenSupply = totalTokenSupply.add(value);
  }
  user.balance = user.balance.add(value);

  emit Increase(account, value, asset, assetValue);
}

function _decrease(address account, uint256 value) internal {
  User storage user = users[account];
  user.balance = user.balance.sub(value);

  if (limited) {
    remainingSupply = remainingSupply.add(value);
  } else {
    totalTokenSupply = totalTokenSupply.sub(value);
  }

  emit Decrease(account, value);
}

constructor() internal {
  pauseState = PauseState(false, false);
}

function _pause(bool attorney) internal {
  pauseState.paused = true;
  pauseState.pausedByAttorney = attorney;
  emit Paused(msg.sender, attorney);
}

function _unpause() internal {
  pauseState.paused = false;
  pauseState.pausedByAttorney = false;
  emit Unpaused(msg.sender);
}

function _addAttorney(address account) internal {
  _add(ATTORNEY, account);
}

function _addAdmin(address account) internal {
  _add(ADMIN, account);
}

function _add(uint8 groupId, address account) internal {
  groups.add(groupId, account);
  emit AddedToGroup(groupId, account);
}

function _remove(uint8 groupId, address account) internal {
  groups.remove(groupId, account);
  emit RemovedFromGroup(groupId, account);
}

function _contains(uint8 groupId, address account)
  internal
  view
  returns (bool)
{
  return groups.contains(groupId, account);
}