function allowance(
         address _owner,
         address _spender)
         public
         view
         returns (uint256)
     {
         return allowed[_owner][_spender];
     }
 

     function balanceOf(
         address _owner)
         public
         view
         returns (uint256)
     {
         return balances[_owner];
     }
 

     function totalSupply()
         public
         view
         returns (uint256)
     {
         return totalSupply_;
     }
 

     event Burn(
         address indexed burner,
         uint256 tokenAmount,
         uint256 assetAmount,
         uint256 price
     );
 

     event Mint(
         address indexed minter,
         uint256 tokenAmount,
         uint256 assetAmount,
         uint256 price
     );
 

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

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

     function setTarget(
         address _newTarget)
         public
         onlyOwner
     {
         _setTarget(_newTarget);
     }
 

     function()
         external
         payable
     {
         address target = target_;
         bytes memory data = msg.data;
         assembly {
             let result := delegatecall(gas, target, add(data, 0x20), mload(data), 0, 0)
             let size := returndatasize
             let ptr := mload(0x40)
             returndatacopy(ptr, 0, size)
             switch result
             case 0 { revert(ptr, size) }
             default { return(ptr, size) }
         }
     }
 

     event Claim(
         address indexed claimant,
         uint256 tokenAmount,
         uint256 assetAmount,
         uint256 remainingTokenAmount,
         uint256 price
     );
 

     event Borrow(
         address indexed borrower,
         uint256 borrowAmount,
         uint256 interestRate,
         address collateralTokenAddress,
         address tradeTokenToFillAddress,
         bool withdrawOnOpen
     );
 

   function transferOwnership(address _newOwner) public onlyOwner {
     _transferOwnership(_newOwner);
   }
 

   constructor() public {
     owner = msg.sender;
   }
 

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

     mapping (uint256 => bytes32) public loanOrderHashes; // mapping of levergeAmount to loanOrderHash
 

     mapping (address => ListIndex) public burntTokenReserveListIndex; // mapping of lender address to ListIndex objects
 

     uint256 public spreadMultiplier;
 

     uint256[] public leverageList;
 

     address public bZxContract;
 

     address public bZxOracle;
 

     string public symbol;
 

   address public owner;
 

     address public bZxVault;
 

     address public loanTokenAddress;
 

     TokenReserves[] public burntTokenReserveList; // array of TokenReserves
 

     address public tokenizedRegistry;
 

     address public wethContract;
 

     uint256 public rateMultiplier = 39000000000000000000; // 39%
 

     uint8 public decimals;
 

     mapping (bytes32 => LoanData) public loanOrderData; // mapping of loanOrderHash to LoanOrder
 

     uint256 public totalAssetBorrow = 0; // current amount of loan token amount tied up in loans
 

     uint256 public baseRate = 1000000000000000000; // 1.0%
 

     uint256 public initialPrice;
 

     uint256 public burntTokenReserved; // total outstanding burnt token amount
 

     string public name;