{ parameter
    (or (or (or (or (pair %addLiquidity (pair address nat) (pair nat timestamp))
                    (pair %approve address (pair nat nat)))
                (or (unit %default)
                    (pair %removeLiquidity
                       (pair address (pair address nat))
                       (pair mutez (pair nat timestamp)))))
            (or (or (pair %setBaker (option key_hash) bool) (address %setManager))
                (or (pair %tokenToXtz (pair address address) (pair nat (pair mutez timestamp)))
                    (key_hash %updateTokenPool))))
        (or (nat %updateTokenPoolInternal) (pair %xtzToToken address (pair nat timestamp)))) ;
  storage
    (pair (big_map %accounts address (pair (map %allowances address nat) (nat %balance)))
          (pair %s
             (pair (pair (bool %freeze_baker) (nat %lqt_total))
                   (pair (address %manager) (bool %self_is_updating_token_pool)))
             (pair (pair (address %token_address) (nat %token_pool)) (mutez %xtz_pool)))) ;
  code { EMPTY_MAP address nat ;
         LAMBDA
           mutez
           nat
           { PUSH mutez 1 ;
             SWAP ;
             EDIV ;
             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
             CAR } ;
         LAMBDA nat mutez { PUSH mutez 1 ; SWAP ; MUL } ;
         DIG 2 ;
         DUP ;
         DUG 3 ;
         LAMBDA
           (pair (map address nat) (pair address (big_map address (pair (map address nat) nat))))
           (pair (map address nat) nat)
           { DUP ;
             CDR ;
             SWAP ;
             CAR ;
             SWAP ;
             DUP ;
             CDR ;
             SWAP ;
             CAR ;
             GET ;
             IF_NONE { PUSH nat 0 ; SWAP ; PAIR } { SWAP ; DROP } } ;
         SWAP ;
         APPLY ;
         DIG 4 ;
         DUP ;
         DUG 5 ;
         CDR ;
         DIG 5 ;
         CAR ;
         IF_LEFT
           { IF_LEFT
               { IF_LEFT
                   { DIG 3 ;
                     DROP ;
                     IF_LEFT
                       { DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CAR ;
                         PAIR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CAR ;
                         CDR ;
                         DIG 3 ;
                         CAR ;
                         CAR ;
                         PAIR ;
                         PAIR ;
                         PAIR ;
                         DUP ;
                         CAR ;
                         CAR ;
                         CAR ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CAR ;
                         CAR ;
                         CDR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CAR ;
                         CDR ;
                         CAR ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         CDR ;
                         DUP ;
                         CDR ;
                         CAR ;
                         CDR ;
                         CDR ;
                         IF { PUSH string "self_is_updating_token_pool must be false" ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         DIG 4 ;
                         CAR ;
                         CDR ;
                         CDR ;
                         NOW ;
                         COMPARE ;
                         LT ;
                         IF { PUSH unit Unit }
                            { PUSH string "The current time must be less than the deadline." ; FAILWITH } ;
                         DROP ;
                         PUSH nat 0 ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         COMPARE ;
                         GT ;
                         IF { PUSH unit Unit }
                            { PUSH string "max_tokens_deposited must be greater than zero." ; FAILWITH } ;
                         DROP ;
                         PUSH mutez 0 ;
                         AMOUNT ;
                         COMPARE ;
                         GT ;
                         IF { PUSH unit Unit }
                            { PUSH string "The amount of XTZ sent to the contract to be greater than zero." ;
                              FAILWITH } ;
                         DROP ;
                         PUSH nat 0 ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         COMPARE ;
                         GT ;
                         IF { PUSH unit Unit }
                            { PUSH string "min_lqt_minted must be greater than zero." ; FAILWITH } ;
                         DROP ;
                         DUP ;
                         NIL operation ;
                         PAIR ;
                         PUSH nat 0 ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CAR ;
                         CAR ;
                         CDR ;
                         COMPARE ;
                         GT ;
                         IF { DIG 7 ;
                              DROP ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              CDR ;
                              CDR ;
                              CDR ;
                              DIG 7 ;
                              DUP ;
                              DUG 8 ;
                              SWAP ;
                              EXEC ;
                              AMOUNT ;
                              DIG 8 ;
                              SWAP ;
                              EXEC ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              DIG 4 ;
                              DUP ;
                              DUG 5 ;
                              CDR ;
                              CDR ;
                              CAR ;
                              CDR ;
                              DIG 2 ;
                              DUP ;
                              DUG 3 ;
                              MUL ;
                              PAIR ;
                              PUSH nat 0 ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              CDR ;
                              DIG 2 ;
                              CAR ;
                              EDIV ;
                              IF_NONE
                                { PUSH string "DIV by 0" ; FAILWITH }
                                { PUSH nat 0 ;
                                  SWAP ;
                                  DUP ;
                                  DUG 2 ;
                                  CDR ;
                                  COMPARE ;
                                  EQ ;
                                  IF { SWAP ; DUP ; DUG 2 ; SWAP ; CAR ; DIP { DROP } }
                                     { PUSH nat 1 ;
                                       SWAP ;
                                       CAR ;
                                       ADD ;
                                       SWAP ;
                                       DUP ;
                                       DUG 2 ;
                                       SWAP ;
                                       DIP { DROP } } ;
                                  DIP { DROP } } ;
                              PUSH nat 0 ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              COMPARE ;
                              GT ;
                              IF { PUSH unit Unit }
                                 { PUSH string "tokens_deposited must be greater than zero." ; FAILWITH } ;
                              DROP ;
                              DUP ;
                              DIG 6 ;
                              COMPARE ;
                              GE ;
                              IF { PUSH unit Unit }
                                 { PUSH string
                                        "max_tokens_deposited must be greater than or equal to tokens_deposited." ;
                                   FAILWITH } ;
                              DROP ;
                              DIG 2 ;
                              DIG 4 ;
                              DUP ;
                              DUG 5 ;
                              CDR ;
                              CAR ;
                              CAR ;
                              CDR ;
                              DIG 3 ;
                              MUL ;
                              EDIV ;
                              IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
                              CAR ;
                              DIG 4 ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              COMPARE ;
                              GE ;
                              IF { PUSH unit Unit }
                                 { PUSH string "lqt_minted must be greater than min_lqt_minted." ; FAILWITH } ;
                              DROP ;
                              DIG 3 ;
                              DUP ;
                              DUG 4 ;
                              CAR ;
                              DIG 5 ;
                              DUP ;
                              DUG 6 ;
                              PAIR ;
                              DIG 6 ;
                              SWAP ;
                              EXEC ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              CDR ;
                              ADD ;
                              DIG 5 ;
                              DUP ;
                              CAR ;
                              DIG 2 ;
                              DIG 3 ;
                              CAR ;
                              PAIR ;
                              DIG 6 ;
                              DUP ;
                              DUG 7 ;
                              SWAP ;
                              SOME ;
                              SWAP ;
                              UPDATE ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              PAIR ;
                              DUP ;
                              DUG 2 ;
                              DUP ;
                              DUG 3 ;
                              CDR ;
                              CAR ;
                              CAR ;
                              CDR ;
                              ADD ;
                              DIP { DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CDR ;
                                    SWAP ;
                                    CAR ;
                                    DUP ;
                                    CDR ;
                                    SWAP ;
                                    CAR ;
                                    CAR } ;
                              SWAP ;
                              PAIR ;
                              PAIR ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              DUP ;
                              DIG 3 ;
                              DUP ;
                              DUG 4 ;
                              DIG 2 ;
                              DUP ;
                              DUG 3 ;
                              CDR ;
                              CDR ;
                              CAR ;
                              CDR ;
                              ADD ;
                              DIP { DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CDR ;
                                    SWAP ;
                                    CAR ;
                                    CAR } ;
                              SWAP ;
                              PAIR ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              DUP ;
                              AMOUNT ;
                              DIG 2 ;
                              DUP ;
                              DUG 3 ;
                              CDR ;
                              CDR ;
                              CDR ;
                              ADD ;
                              DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              DUP ;
                              CDR ;
                              CDR ;
                              CAR ;
                              CAR ;
                              CONTRACT %transfer (pair address (pair address nat)) ;
                              IF_NONE
                                { PUSH string "bad address for get_entrypoint (%transfer)" ; FAILWITH }
                                {} ;
                              PUSH mutez 0 ;
                              DIG 6 ;
                              SELF ;
                              ADDRESS ;
                              PAIR ;
                              DIG 8 ;
                              PAIR ;
                              TRANSFER_TOKENS ;
                              DIG 5 ;
                              DIG 5 ;
                              SWAP ;
                              CAR ;
                              PAIR ;
                              DIG 4 ;
                              SWAP ;
                              CAR ;
                              PAIR ;
                              DIG 3 ;
                              SWAP ;
                              CAR ;
                              PAIR ;
                              DIG 2 ;
                              SWAP ;
                              CAR ;
                              PAIR ;
                              NIL operation ;
                              DIG 2 ;
                              CONS ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              PAIR }
                            { DIG 3 ;
                              DROP ;
                              DIG 4 ;
                              DROP ;
                              PUSH mutez 1000000 ;
                              AMOUNT ;
                              COMPARE ;
                              GE ;
                              IF { PUSH unit Unit }
                                 { PUSH string "The initial liquidity amount must be greater than or equal to zero." ;
                                   FAILWITH } ;
                              DROP ;
                              AMOUNT ;
                              DIG 2 ;
                              DUP ;
                              DUG 3 ;
                              CDR ;
                              CDR ;
                              CDR ;
                              ADD ;
                              DIG 5 ;
                              SWAP ;
                              EXEC ;
                              DIG 2 ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              DIP { DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CDR ;
                                    SWAP ;
                                    CAR ;
                                    DUP ;
                                    CDR ;
                                    SWAP ;
                                    CAR ;
                                    CAR } ;
                              SWAP ;
                              PAIR ;
                              PAIR ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              DUP ;
                              DUP ;
                              DUG 2 ;
                              CAR ;
                              DIG 3 ;
                              DIG 7 ;
                              PAIR ;
                              DIG 6 ;
                              DUP ;
                              DUG 7 ;
                              SWAP ;
                              SOME ;
                              SWAP ;
                              UPDATE ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              PAIR ;
                              DUP ;
                              DIG 4 ;
                              DUP ;
                              DUG 5 ;
                              DIP { DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CDR ;
                                    SWAP ;
                                    CAR ;
                                    CAR } ;
                              SWAP ;
                              PAIR ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              DUP ;
                              AMOUNT ;
                              DIG 2 ;
                              DUP ;
                              DUG 3 ;
                              CDR ;
                              CDR ;
                              CDR ;
                              ADD ;
                              DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              DUP ;
                              CDR ;
                              CDR ;
                              CAR ;
                              CAR ;
                              CONTRACT %transfer (pair address (pair address nat)) ;
                              IF_NONE
                                { PUSH string "bad address for get_entrypoint (%transfer)" ; FAILWITH }
                                {} ;
                              PUSH mutez 0 ;
                              DIG 7 ;
                              SELF ;
                              ADDRESS ;
                              PAIR ;
                              DIG 8 ;
                              PAIR ;
                              TRANSFER_TOKENS ;
                              DIG 5 ;
                              DIG 5 ;
                              SWAP ;
                              CAR ;
                              PAIR ;
                              DIG 4 ;
                              SWAP ;
                              CAR ;
                              PAIR ;
                              DIG 3 ;
                              SWAP ;
                              CAR ;
                              PAIR ;
                              DIG 2 ;
                              SWAP ;
                              CAR ;
                              PAIR ;
                              NIL operation ;
                              DIG 2 ;
                              CONS ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              PAIR } }
                       { DIG 3 ;
                         DROP ;
                         DIG 3 ;
                         DROP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         PAIR ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CAR ;
                         DIG 2 ;
                         CAR ;
                         PAIR ;
                         PAIR ;
                         DUP ;
                         CAR ;
                         CAR ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         DUP ;
                         CDR ;
                         CAR ;
                         CDR ;
                         CDR ;
                         IF { PUSH string "self_is_updating_token_pool must be false" ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         PUSH mutez 0 ;
                         AMOUNT ;
                         COMPARE ;
                         GT ;
                         IF { PUSH string "amount must be zero." ; FAILWITH } { PUSH unit Unit } ;
                         DROP ;
                         DUP ;
                         CAR ;
                         SENDER ;
                         PAIR ;
                         DIG 4 ;
                         SWAP ;
                         EXEC ;
                         DUP ;
                         CAR ;
                         PUSH nat 0 ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         PAIR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         DIG 6 ;
                         DUP ;
                         DUG 7 ;
                         GET ;
                         IF_NONE { SWAP } { DIG 2 ; SWAP ; DIP { DROP } } ;
                         DIG 6 ;
                         DUP ;
                         DUG 7 ;
                         CDR ;
                         CAR ;
                         COMPARE ;
                         EQ ;
                         IF { SWAP ;
                              DIG 5 ;
                              CAR ;
                              CDR ;
                              DIG 5 ;
                              SWAP ;
                              SOME ;
                              SWAP ;
                              UPDATE ;
                              DIG 3 ;
                              DUP ;
                              CAR ;
                              DIG 4 ;
                              CDR ;
                              DIG 3 ;
                              DUP ;
                              DUG 4 ;
                              PAIR ;
                              SOME ;
                              SENDER ;
                              UPDATE ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              PAIR ;
                              DUG 2 ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              PAIR ;
                              CAR ;
                              PAIR }
                            { SWAP ;
                              DROP ;
                              SWAP ;
                              DROP ;
                              SWAP ;
                              DROP ;
                              SWAP ;
                              DROP ;
                              SWAP ;
                              DROP ;
                              PUSH string "current_allowance must equal account.allowances[spender]." ;
                              FAILWITH } ;
                         CDR ;
                         NIL operation ;
                         PAIR } }
                   { DIG 5 ;
                     DROP ;
                     IF_LEFT
                       { DIG 2 ;
                         DROP ;
                         DIG 2 ;
                         DROP ;
                         DIG 2 ;
                         DROP 2 ;
                         DUP ;
                         AMOUNT ;
                         DIG 2 ;
                         CDR ;
                         CDR ;
                         CDR ;
                         ADD ;
                         DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                         SWAP ;
                         PAIR ;
                         SWAP ;
                         PAIR ;
                         SWAP ;
                         PAIR ;
                         NIL operation ;
                         PAIR }
                       { DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CDR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         PAIR ;
                         PAIR ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CAR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CAR ;
                         CDR ;
                         CDR ;
                         PAIR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CAR ;
                         CDR ;
                         CAR ;
                         DIG 3 ;
                         CAR ;
                         CAR ;
                         PAIR ;
                         PAIR ;
                         PAIR ;
                         DUP ;
                         CAR ;
                         CAR ;
                         CAR ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CAR ;
                         CAR ;
                         CDR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CAR ;
                         CDR ;
                         CAR ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         CAR ;
                         CDR ;
                         CDR ;
                         DIG 4 ;
                         DUP ;
                         DUG 5 ;
                         CDR ;
                         CAR ;
                         CAR ;
                         DIG 5 ;
                         DUP ;
                         DUG 6 ;
                         CDR ;
                         CDR ;
                         DUP ;
                         CDR ;
                         CAR ;
                         CDR ;
                         CDR ;
                         IF { PUSH string "self_is_updating_token_pool must be false" ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         DIG 6 ;
                         CDR ;
                         CAR ;
                         CDR ;
                         NOW ;
                         COMPARE ;
                         LT ;
                         IF { PUSH unit Unit }
                            { PUSH string "The current time must be less than the deadline." ; FAILWITH } ;
                         DROP ;
                         PUSH mutez 0 ;
                         AMOUNT ;
                         COMPARE ;
                         GT ;
                         IF { PUSH string "amount must be zero." ; FAILWITH } { PUSH unit Unit } ;
                         DROP ;
                         PUSH mutez 0 ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         COMPARE ;
                         GT ;
                         IF { PUSH unit Unit }
                            { PUSH string "min_xtz_withdrawn must be greater than zero." ; FAILWITH } ;
                         DROP ;
                         PUSH nat 0 ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         COMPARE ;
                         GT ;
                         IF { PUSH unit Unit }
                            { PUSH string "min_tokens_withdrawn must be greater than zero." ; FAILWITH } ;
                         DROP ;
                         PUSH nat 0 ;
                         DIG 4 ;
                         DUP ;
                         DUG 5 ;
                         COMPARE ;
                         GT ;
                         IF { PUSH unit Unit }
                            { PUSH string "lqt_burned must be greater than zero." ; FAILWITH } ;
                         DROP ;
                         PUSH nat 0 ;
                         DUP ;
                         PUSH nat 0 ;
                         PAIR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CAR ;
                         DIG 8 ;
                         DUP ;
                         DUG 9 ;
                         GET ;
                         IF_NONE
                           { SWAP ;
                             DROP ;
                             PUSH string "The owner does not have any liquidity in this contract." ;
                             FAILWITH }
                           { DIG 8 ;
                             DUP ;
                             DUG 9 ;
                             SENDER ;
                             COMPARE ;
                             NEQ ;
                             IF { DUP ;
                                  CAR ;
                                  SENDER ;
                                  GET ;
                                  IF_NONE
                                    { PUSH string
                                           "The sender does not have an allowance from the give owner in this contract." ;
                                      FAILWITH }
                                    { DUP ;
                                      DIG 8 ;
                                      DUP ;
                                      DUG 9 ;
                                      COMPARE ;
                                      GT ;
                                      IF { PUSH string "lqt_burned cannot be greater than the sender's allowance." ;
                                           FAILWITH }
                                         { PUSH unit Unit } ;
                                      DROP ;
                                      DIG 3 ;
                                      DUP ;
                                      DUG 4 ;
                                      SWAP ;
                                      DIP { DROP } } ;
                                  DIG 3 ;
                                  SWAP ;
                                  DIP { DROP } }
                                { DIG 2 } ;
                             DUG 2 ;
                             CDR ;
                             SWAP ;
                             CDR ;
                             SWAP ;
                             PAIR ;
                             CAR ;
                             PAIR } ;
                         DUP ;
                         CAR ;
                         DIG 5 ;
                         DUP ;
                         DUG 6 ;
                         COMPARE ;
                         GT ;
                         IF { PUSH string "lqt_burned cannot be greater than the owner's balance." ;
                              FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CAR ;
                         CAR ;
                         CDR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CDR ;
                         CDR ;
                         DIG 11 ;
                         SWAP ;
                         EXEC ;
                         DIG 6 ;
                         DUP ;
                         DUG 7 ;
                         MUL ;
                         EDIV ;
                         IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
                         CAR ;
                         DIG 9 ;
                         SWAP ;
                         EXEC ;
                         DIG 4 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         COMPARE ;
                         GE ;
                         IF { PUSH unit Unit }
                            { PUSH string
                                   "The amount of xtz withdrawn must be greater than or equal to min_xtz_withdrawn." ;
                              FAILWITH } ;
                         DROP ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CAR ;
                         CAR ;
                         CDR ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         CDR ;
                         DIG 6 ;
                         DUP ;
                         DUG 7 ;
                         MUL ;
                         EDIV ;
                         IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
                         CAR ;
                         DIG 4 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         COMPARE ;
                         GE ;
                         IF { PUSH unit Unit }
                            { PUSH string
                                   "The amount of tokens withdrawn must be greater than or equal to min_tokens_withdrawn." ;
                              FAILWITH } ;
                         DROP ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         CAR ;
                         DIG 7 ;
                         DUP ;
                         DUG 8 ;
                         PAIR ;
                         DIG 8 ;
                         DUP ;
                         DUG 9 ;
                         SWAP ;
                         EXEC ;
                         DIG 5 ;
                         DUP ;
                         DUG 6 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         SUB ;
                         PUSH nat 0 ;
                         PUSH int 0 ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         COMPARE ;
                         GE ;
                         IF { SWAP ; ABS ; DIP { DROP } }
                            { SWAP ;
                              DROP ;
                              PUSH string "account.balance - lqt_burned resulted in a negative number." ;
                              FAILWITH } ;
                         DIG 5 ;
                         DUP ;
                         CAR ;
                         DIG 2 ;
                         DIG 3 ;
                         CAR ;
                         PAIR ;
                         DIG 8 ;
                         DUP ;
                         DUG 9 ;
                         SWAP ;
                         SOME ;
                         SWAP ;
                         UPDATE ;
                         SWAP ;
                         CDR ;
                         SWAP ;
                         PAIR ;
                         DIG 4 ;
                         DUP ;
                         DUG 5 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CAR ;
                         CAR ;
                         CDR ;
                         SUB ;
                         DROP ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         CDR ;
                         SUB ;
                         PUSH int 0 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         COMPARE ;
                         GE ;
                         IF { SWAP ;
                              DUP ;
                              DIG 2 ;
                              ABS ;
                              DIP { DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CDR ;
                                    SWAP ;
                                    CAR ;
                                    CAR } ;
                              SWAP ;
                              PAIR ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              DIP { DROP } }
                            { DROP ;
                              PUSH string
                                   "storage.s.token_pool - tokens_withdrawn resulted in a negative number." ;
                              FAILWITH } ;
                         SENDER ;
                         DIG 7 ;
                         DUP ;
                         DUG 8 ;
                         COMPARE ;
                         NEQ ;
                         IF { DIG 4 ;
                              DIG 4 ;
                              CDR ;
                              SUB ;
                              PUSH int 0 ;
                              SWAP ;
                              DUP ;
                              DUG 2 ;
                              COMPARE ;
                              GE ;
                              IF { SWAP ;
                                   DUP ;
                                   DUG 2 ;
                                   CAR ;
                                   DIG 6 ;
                                   DUP ;
                                   DUG 7 ;
                                   PAIR ;
                                   DIG 7 ;
                                   SWAP ;
                                   EXEC ;
                                   DUP ;
                                   CAR ;
                                   DIG 2 ;
                                   ABS ;
                                   SOME ;
                                   SENDER ;
                                   UPDATE ;
                                   SWAP ;
                                   CDR ;
                                   SWAP ;
                                   PAIR ;
                                   SWAP ;
                                   DUP ;
                                   DUP ;
                                   DUP ;
                                   DUG 4 ;
                                   CAR ;
                                   DIG 3 ;
                                   DIG 8 ;
                                   SWAP ;
                                   SOME ;
                                   SWAP ;
                                   UPDATE ;
                                   SWAP ;
                                   CDR ;
                                   SWAP ;
                                   PAIR ;
                                   DIP { DROP } }
                                 { DROP ;
                                   DIG 4 ;
                                   DROP ;
                                   DIG 4 ;
                                   DROP ;
                                   PUSH string "sender_allowance - lqt_burned resulted in a negative number" ;
                                   FAILWITH } ;
                              DIP { DROP } }
                            { DIG 3 ; DROP ; DIG 3 ; DROP ; DIG 4 ; DROP ; DIG 4 ; DROP } ;
                         DUP ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         DIG 2 ;
                         CDR ;
                         CDR ;
                         CDR ;
                         SUB ;
                         DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                         SWAP ;
                         PAIR ;
                         SWAP ;
                         PAIR ;
                         SWAP ;
                         PAIR ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         CONTRACT unit ;
                         IF_NONE { PUSH string "bad address for get_contract" ; FAILWITH } {} ;
                         DIG 3 ;
                         UNIT ;
                         TRANSFER_TOKENS ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         CAR ;
                         CONTRACT %transfer (pair address (pair address nat)) ;
                         IF_NONE
                           { PUSH string "bad address for get_entrypoint (%transfer)" ; FAILWITH }
                           {} ;
                         PUSH mutez 0 ;
                         DIG 4 ;
                         DIG 5 ;
                         PAIR ;
                         SELF ;
                         ADDRESS ;
                         PAIR ;
                         TRANSFER_TOKENS ;
                         DIG 2 ;
                         NIL operation ;
                         DIG 2 ;
                         CONS ;
                         DIG 2 ;
                         CONS ;
                         PAIR } } }
               { DIG 2 ;
                 DROP ;
                 DIG 4 ;
                 DROP ;
                 IF_LEFT
                   { DIG 2 ;
                     DROP ;
                     DIG 2 ;
                     DROP ;
                     IF_LEFT
                       { PAIR ;
                         DUP ;
                         CDR ;
                         NIL operation ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CAR ;
                         CDR ;
                         CDR ;
                         IF { PUSH string "self_is_updating_token_pool must be false" ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         PUSH mutez 0 ;
                         AMOUNT ;
                         COMPARE ;
                         GT ;
                         IF { PUSH string "amount must be zero." ; FAILWITH } { PUSH unit Unit } ;
                         DROP ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         PAIR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CAR ;
                         CDR ;
                         CAR ;
                         SENDER ;
                         COMPARE ;
                         EQ ;
                         IF { DIG 2 ;
                              DUP ;
                              DUG 3 ;
                              DIG 2 ;
                              PAIR ;
                              PUSH bool False ;
                              DIG 3 ;
                              DUP ;
                              DUG 4 ;
                              CDR ;
                              CAR ;
                              CAR ;
                              CAR ;
                              COMPARE ;
                              EQ ;
                              IF { NIL operation ;
                                   DIG 4 ;
                                   DUP ;
                                   DUG 5 ;
                                   CAR ;
                                   CAR ;
                                   SET_DELEGATE ;
                                   CONS ;
                                   SWAP ;
                                   CDR ;
                                   SWAP ;
                                   PAIR ;
                                   DIG 2 ;
                                   DIG 3 ;
                                   CAR ;
                                   CDR ;
                                   DIP { DUP ;
                                         CAR ;
                                         SWAP ;
                                         CDR ;
                                         DUP ;
                                         CDR ;
                                         SWAP ;
                                         CAR ;
                                         DUP ;
                                         CDR ;
                                         SWAP ;
                                         CAR ;
                                         CDR } ;
                                   PAIR ;
                                   PAIR ;
                                   PAIR ;
                                   SWAP ;
                                   PAIR ;
                                   SWAP ;
                                   CAR ;
                                   PAIR }
                                 { DIG 2 ;
                                   DROP ;
                                   DIG 2 ;
                                   DROP ;
                                   PUSH string "The baker is frozen." ;
                                   FAILWITH } ;
                              DUP ;
                              DUG 2 ;
                              CAR ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              CAR ;
                              PAIR }
                            { SWAP ;
                              DROP ;
                              SWAP ;
                              DROP ;
                              SWAP ;
                              DROP ;
                              PUSH string "only the manager can set the baker." ;
                              FAILWITH } }
                       { PAIR ;
                         DUP ;
                         CDR ;
                         DUP ;
                         CDR ;
                         CAR ;
                         CDR ;
                         CDR ;
                         IF { PUSH string "self_is_updating_token_pool must be false" ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         PUSH mutez 0 ;
                         AMOUNT ;
                         COMPARE ;
                         GT ;
                         IF { PUSH string "amount must be zero." ; FAILWITH } { PUSH unit Unit } ;
                         DROP ;
                         DUP ;
                         CDR ;
                         CAR ;
                         CDR ;
                         CAR ;
                         SENDER ;
                         COMPARE ;
                         EQ ;
                         IF { DUP ;
                              DIG 2 ;
                              CAR ;
                              DIP { DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    DUP ;
                                    CDR ;
                                    SWAP ;
                                    CAR ;
                                    DUP ;
                                    CAR ;
                                    SWAP ;
                                    CDR ;
                                    CDR } ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              DIP { DROP } }
                            { SWAP ;
                              DROP ;
                              PUSH string "Only the manager can change the manager." ;
                              FAILWITH } ;
                         NIL operation ;
                         PAIR } }
                   { IF_LEFT
                       { DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CDR ;
                         PAIR ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CAR ;
                         PAIR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CAR ;
                         CDR ;
                         DIG 3 ;
                         CAR ;
                         CAR ;
                         PAIR ;
                         PAIR ;
                         PAIR ;
                         DUP ;
                         CAR ;
                         CDR ;
                         CAR ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CAR ;
                         CDR ;
                         CDR ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CDR ;
                         DUP ;
                         CDR ;
                         CAR ;
                         CDR ;
                         CDR ;
                         IF { PUSH string "self_is_updating_token_pool must be false" ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         CDR ;
                         CAR ;
                         NOW ;
                         COMPARE ;
                         LT ;
                         IF { PUSH unit Unit }
                            { PUSH string "The current time must be less than the deadline." ; FAILWITH } ;
                         DROP ;
                         PUSH mutez 0 ;
                         AMOUNT ;
                         COMPARE ;
                         GT ;
                         IF { PUSH string "amount must be zero." ; FAILWITH } { PUSH unit Unit } ;
                         DROP ;
                         PUSH nat 0 ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         COMPARE ;
                         GT ;
                         IF { PUSH string "tokens_sold must be greater than zero." ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         PUSH mutez 0 ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         COMPARE ;
                         GT ;
                         IF { PUSH string "min_xtz_bought must be greater than zero." ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         PUSH mutez 0 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CDR ;
                         COMPARE ;
                         EQ ;
                         IF { PUSH string "xtz_pool must be greater than zero." ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         PUSH nat 0 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         CDR ;
                         COMPARE ;
                         EQ ;
                         IF { PUSH string "token_pool must be greater than zero." ; FAILWITH }
                            { PUSH unit Unit } ;
                         DROP ;
                         PUSH nat 997 ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         MUL ;
                         PUSH nat 1000 ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         CDR ;
                         MUL ;
                         ADD ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CDR ;
                         DIG 7 ;
                         SWAP ;
                         EXEC ;
                         PUSH nat 997 ;
                         DIG 5 ;
                         DUP ;
                         DUG 6 ;
                         MUL ;
                         MUL ;
                         EDIV ;
                         IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
                         CAR ;
                         DIG 5 ;
                         SWAP ;
                         EXEC ;
                         DIG 2 ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         COMPARE ;
                         GE ;
                         IF { PUSH unit Unit }
                            { PUSH string "xtz_bought must be greater than or equal to min_xtz_bought." ;
                              FAILWITH } ;
                         DROP ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         DIG 3 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         CDR ;
                         ADD ;
                         DIP { DUP ;
                               CAR ;
                               SWAP ;
                               CDR ;
                               DUP ;
                               CAR ;
                               SWAP ;
                               CDR ;
                               DUP ;
                               CDR ;
                               SWAP ;
                               CAR ;
                               CAR } ;
                         SWAP ;
                         PAIR ;
                         PAIR ;
                         SWAP ;
                         PAIR ;
                         SWAP ;
                         PAIR ;
                         DUP ;
                         DIG 2 ;
                         DUP ;
                         DUG 3 ;
                         DIG 2 ;
                         CDR ;
                         CDR ;
                         CDR ;
                         SUB ;
                         DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                         SWAP ;
                         PAIR ;
                         SWAP ;
                         PAIR ;
                         SWAP ;
                         PAIR ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         CAR ;
                         CAR ;
                         CDR ;
                         CONTRACT unit ;
                         IF_NONE { PUSH string "bad address for get_contract" ; FAILWITH } {} ;
                         DIG 2 ;
                         UNIT ;
                         TRANSFER_TOKENS ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         CDR ;
                         CDR ;
                         CAR ;
                         CAR ;
                         CONTRACT %transfer (pair address (pair address nat)) ;
                         IF_NONE
                           { PUSH string "bad address for get_entrypoint (%transfer)" ; FAILWITH }
                           {} ;
                         PUSH mutez 0 ;
                         DIG 4 ;
                         SELF ;
                         ADDRESS ;
                         PAIR ;
                         DIG 5 ;
                         CAR ;
                         CAR ;
                         CAR ;
                         PAIR ;
                         TRANSFER_TOKENS ;
                         DIG 2 ;
                         NIL operation ;
                         DIG 2 ;
                         CONS ;
                         DIG 2 ;
                         CONS ;
                         PAIR }
                       { DIG 2 ;
                         DROP ;
                         DIG 2 ;
                         DROP ;
                         IMPLICIT_ACCOUNT ;
                         SWAP ;
                         DUP ;
                         DUG 2 ;
                         NIL operation ;
                         PAIR ;
                         SWAP ;
                         ADDRESS ;
                         SENDER ;
                         COMPARE ;
                         EQ ;
                         IF { SELF %updateTokenPoolInternal ;
                              DIG 2 ;
                              DUP ;
                              DUG 3 ;
                              CDR ;
                              CDR ;
                              CAR ;
                              CAR ;
                              CONTRACT %getBalance (pair address (contract nat)) ;
                              IF_NONE
                                { PUSH string "bad address for get_entrypoint (%getBalance)" ; FAILWITH }
                                {} ;
                              PUSH mutez 0 ;
                              DIG 2 ;
                              SELF ;
                              ADDRESS ;
                              PAIR ;
                              TRANSFER_TOKENS ;
                              SWAP ;
                              NIL operation ;
                              DIG 2 ;
                              CONS ;
                              SWAP ;
                              CDR ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              DUP ;
                              CAR ;
                              SWAP ;
                              CDR ;
                              DUP ;
                              CDR ;
                              SWAP ;
                              CAR ;
                              DUP ;
                              CAR ;
                              SWAP ;
                              CDR ;
                              CAR ;
                              PUSH bool True ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              PAIR ;
                              SWAP ;
                              PAIR ;
                              SWAP ;
                              CAR ;
                              PAIR }
                            { SWAP ; DROP ; PUSH string "UnsafeUpdateTokenPool" ; FAILWITH } } } } }
           { DIG 2 ;
             DROP ;
             DIG 2 ;
             DROP ;
             DIG 3 ;
             DROP ;
             IF_LEFT
               { DIG 2 ;
                 DROP ;
                 PAIR ;
                 DUP ;
                 CDR ;
                 DUP ;
                 CDR ;
                 CDR ;
                 CAR ;
                 CAR ;
                 SENDER ;
                 COMPARE ;
                 NEQ ;
                 SWAP ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 CAR ;
                 CDR ;
                 CDR ;
                 NOT ;
                 OR ;
                 IF { SWAP ;
                      DROP ;
                      PUSH string
                           "This entrypoint may only be called by dexter itself via getBalance of tokenAddress." ;
                      FAILWITH }
                    { DUP ;
                      DIG 2 ;
                      CAR ;
                      DIP { DUP ;
                            CAR ;
                            SWAP ;
                            CDR ;
                            DUP ;
                            CAR ;
                            SWAP ;
                            CDR ;
                            DUP ;
                            CDR ;
                            SWAP ;
                            CAR ;
                            CAR } ;
                      SWAP ;
                      PAIR ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      DUP ;
                      DUG 2 ;
                      DIP { DROP } ;
                      SWAP ;
                      DUP ;
                      CAR ;
                      SWAP ;
                      CDR ;
                      DUP ;
                      CDR ;
                      SWAP ;
                      CAR ;
                      DUP ;
                      CAR ;
                      SWAP ;
                      CDR ;
                      CAR ;
                      PUSH bool False ;
                      SWAP ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      DIP { DROP } } ;
                 NIL operation ;
                 PAIR }
               { DUP ;
                 DUG 2 ;
                 CDR ;
                 CDR ;
                 PAIR ;
                 SWAP ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 CAR ;
                 DIG 2 ;
                 CAR ;
                 PAIR ;
                 PAIR ;
                 DUP ;
                 CAR ;
                 CDR ;
                 SWAP ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 CDR ;
                 DUP ;
                 CDR ;
                 CAR ;
                 CDR ;
                 CDR ;
                 IF { PUSH string "self_is_updating_token_pool must be false" ; FAILWITH }
                    { PUSH unit Unit } ;
                 DROP ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CDR ;
                 CAR ;
                 NOW ;
                 COMPARE ;
                 LT ;
                 IF { PUSH unit Unit }
                    { PUSH string "The current time must be less than the deadline." ; FAILWITH } ;
                 DROP ;
                 PUSH mutez 0 ;
                 AMOUNT ;
                 COMPARE ;
                 EQ ;
                 IF { PUSH string "amount must be greater than zero." ; FAILWITH }
                    { PUSH unit Unit } ;
                 DROP ;
                 PUSH nat 0 ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 COMPARE ;
                 EQ ;
                 IF { PUSH string "min_tokens_bought must be greater than zero." ; FAILWITH }
                    { PUSH unit Unit } ;
                 DROP ;
                 PUSH mutez 0 ;
                 SWAP ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 CDR ;
                 CDR ;
                 COMPARE ;
                 EQ ;
                 IF { PUSH string "xtz_pool must be greater than zero." ; FAILWITH }
                    { PUSH unit Unit } ;
                 DROP ;
                 PUSH nat 0 ;
                 SWAP ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 CDR ;
                 CAR ;
                 CDR ;
                 COMPARE ;
                 EQ ;
                 IF { PUSH string "token_pool must be greater than zero." ; FAILWITH }
                    { PUSH unit Unit } ;
                 DROP ;
                 DUP ;
                 CDR ;
                 CDR ;
                 CDR ;
                 DIG 4 ;
                 DUP ;
                 DUG 5 ;
                 SWAP ;
                 EXEC ;
                 AMOUNT ;
                 DIG 5 ;
                 SWAP ;
                 EXEC ;
                 PUSH nat 997 ;
                 SWAP ;
                 DUP ;
                 DUG 2 ;
                 MUL ;
                 PUSH nat 1000 ;
                 DIG 3 ;
                 MUL ;
                 ADD ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CDR ;
                 CDR ;
                 CAR ;
                 CDR ;
                 PUSH nat 997 ;
                 DIG 3 ;
                 MUL ;
                 MUL ;
                 EDIV ;
                 IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
                 CAR ;
                 DIG 2 ;
                 SWAP ;
                 DUP ;
                 DUG 2 ;
                 COMPARE ;
                 GE ;
                 IF { PUSH unit Unit }
                    { PUSH string "tokens_bought must be greater than or equal to min_tokens_bought." ;
                      FAILWITH } ;
                 DROP ;
                 DUP ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CDR ;
                 CDR ;
                 CAR ;
                 CDR ;
                 SUB ;
                 PUSH int 0 ;
                 SWAP ;
                 DUP ;
                 DUG 2 ;
                 COMPARE ;
                 GE ;
                 IF { DIG 2 ;
                      DUP ;
                      DIG 2 ;
                      ABS ;
                      DIP { DUP ;
                            CAR ;
                            SWAP ;
                            CDR ;
                            DUP ;
                            CAR ;
                            SWAP ;
                            CDR ;
                            DUP ;
                            CDR ;
                            SWAP ;
                            CAR ;
                            CAR } ;
                      SWAP ;
                      PAIR ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      DIP { DROP } }
                    { DROP ; PUSH string "token_pool - tokens_bought is negative." ; FAILWITH } ;
                 DUP ;
                 AMOUNT ;
                 DIG 2 ;
                 CDR ;
                 CDR ;
                 CDR ;
                 ADD ;
                 DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                 SWAP ;
                 PAIR ;
                 SWAP ;
                 PAIR ;
                 SWAP ;
                 PAIR ;
                 DUP ;
                 CDR ;
                 CDR ;
                 CAR ;
                 CAR ;
                 CONTRACT %transfer (pair address (pair address nat)) ;
                 IF_NONE
                   { PUSH string "bad address for get_entrypoint (%transfer)" ; FAILWITH }
                   {} ;
                 PUSH mutez 0 ;
                 DIG 3 ;
                 DIG 4 ;
                 CAR ;
                 CAR ;
                 PAIR ;
                 SELF ;
                 ADDRESS ;
                 PAIR ;
                 TRANSFER_TOKENS ;
                 SWAP ;
                 NIL operation ;
                 DIG 2 ;
                 CONS ;
                 PAIR } } } }