parameter (or (unit %request_balance)

              (or (nat %set_fa1_balance)

                  (or (list %set_fa2_balance (pair (pair address nat) nat))

                      (or (option %set_pool_delegate key_hash)

                          (or

                            (or %set_flat_curve_exponent (unit %exponent8)

                                                         (or (unit %exponent6)

                                                             (unit %exponent4)))

                            (or (address %set_target_oracle)

                                (or

                                  (pair %set_swap_fee_ratio (nat %numerator)

                                                            (nat %denominator))

                                  (or (address %remove_admin)

                                      (or (unit %accept_admin_proposal)

                                          (or (address %propose_admin)

                                              (or (address %set_baking_rewards_receiver)

                                                  (or

                                                    (pair %set_rewards_receiver_ratio

                                                      (nat %numerator)

                                                      (nat %denominator))

                                                    (or (address %set_rewards_receiver)

                                                        (or (address %set_lqt_address)

                                                            (or

                                                              (pair %token_swap_internal

                                                                (pair

                                                                  (or %src_token

                                                                    (pair %fa2 address

                                                                               nat)

                                                                    (or (address %fa1)

                                                                        (unit %tez)))

                                                                  (or %dst_token

                                                                    (pair %fa2 address

                                                                               nat)

                                                                    (or (address %fa1)

                                                                        (unit %tez)))

                                                                  (nat %amount_sold)

                                                                  (nat %min_amount_bought)

                                                                  (address %receiver)

                                                                  (timestamp %deadline))

                                                                address)

                                                              (or

                                                                (pair %token_swap

                                                                  (or %src_token

                                                                    (pair %fa2 address

                                                                               nat)

                                                                    (or (address %fa1)

                                                                        (unit %tez)))

                                                                  (or %dst_token

                                                                    (pair %fa2 address

                                                                               nat)

                                                                    (or (address %fa1)

                                                                        (unit %tez)))

                                                                  (nat %amount_sold)

                                                                  (nat %min_amount_bought)

                                                                  (address %receiver)

                                                                  (timestamp %deadline))

                                                                (or

                                                                  (pair %remove_liquidity_internal

                                                                    (pair

                                                                      (address %receiver)

                                                                      (nat %lqt_burned)

                                                                      (map %min_tokens_withdrawn

                                                                        (or

                                                                          (pair %fa2

                                                                            address

                                                                            nat)

                                                                          (or

                                                                            (address %fa1)

                                                                            (unit %tez)))

                                                                        nat)

                                                                      (timestamp %deadline))

                                                                    address)

                                                                  (or

                                                                    (pair %remove_liquidity

                                                                      (address %receiver)

                                                                      (nat %lqt_burned)

                                                                      (map %min_tokens_withdrawn

                                                                        (or

                                                                          (pair %fa2

                                                                            address

                                                                            nat)

                                                                          (or

                                                                            (address %fa1)

                                                                            (unit %tez)))

                                                                        nat)

                                                                      (timestamp %deadline))

                                                                    (or

                                                                      (pair %add_liquidity_internal

                                                                        (pair

                                                                          (address %owner)

                                                                          (nat %min_lqt_minted)

                                                                          (or %src_token

                                                                            (pair %fa2

                                                                              address

                                                                              nat)

                                                                            (or

                                                                              (address %fa1)

                                                                              (unit %tez)))

                                                                          (nat %src_token_amount)

                                                                          (map %remaining_tokens_max_deposited

                                                                            (or

                                                                              (pair %fa2

                                                                                address

                                                                                nat)

                                                                              (or

                                                                                (address %fa1)

                                                                                (unit %tez)))

                                                                            nat)

                                                                          (timestamp %deadline))

                                                                        address)

                                                                      (or

                                                                        (pair %add_liquidity

                                                                          (address %owner)

                                                                          (nat %min_lqt_minted)

                                                                          (or %src_token

                                                                            (pair %fa2

                                                                              address

                                                                              nat)

                                                                            (or

                                                                              (address %fa1)

                                                                              (unit %tez)))

                                                                          (nat %src_token_amount)

                                                                          (map %remaining_tokens_max_deposited

                                                                            (or

                                                                              (pair %fa2

                                                                                address

                                                                                nat)

                                                                              (or

                                                                                (address %fa1)

                                                                                (unit %tez)))

                                                                            nat)

                                                                          (timestamp %deadline))

                                                                        (unit %default)))))))))))))))))))));

storage (pair (big_map %administrators address (or (unit %proposed) (unit %set)))

              (nat %lqt_total)

              (address %lqt_address)

              (pair %swap_fee_ratio (nat %numerator) (nat %denominator))

              (address %rewards_receiver)

              (pair %rewards_receiver_ratio (nat %numerator) (nat %denominator))

              (address %baking_rewards_receiver)

              (map %tokens_info

                (or (pair %fa2 address nat) (or (address %fa1) (unit %tez)))

                (pair (nat %funds) (nat %multiplier)))

              (address %target_oracle)

              (or %curve_exponent (unit %exponent8)

                                  (or (unit %exponent6) (unit %exponent4))));

code { LAMBDA

         (pair (or (pair address nat) (or address unit)) address address nat

               (or unit unit))

         (option operation)

         { UNPAIR 5 ;

           IF_LEFT

             { DIG 4 ;

               DROP ;

               UNPAIR ;

               CONTRACT %transfer (list (pair address (list (pair address nat nat)))) ;

               IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

               PUSH mutez 0 ;

               NIL (pair address (list (pair address nat nat))) ;

               NIL (pair address nat nat) ;

               DIG 7 ;

               DIG 5 ;

               PAIR ;

               DIG 6 ;

               PAIR ;

               CONS ;

               DIG 4 ;

               PAIR ;

               CONS ;

               TRANSFER_TOKENS ;

               SOME }

             { IF_LEFT

                 { DIG 4 ;

                   DROP ;

                   CONTRACT %transfer (pair address address nat) ;

                   IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

                   PUSH mutez 0 ;

                   DIG 4 ;

                   DIG 4 ;

                   PAIR ;

                   DIG 3 ;

                   PAIR ;

                   TRANSFER_TOKENS ;

                   SOME }

                 { DROP 2 ;

                   DIG 2 ;

                   IF_LEFT

                     { DROP ;

                       CONTRACT unit ;

                       IF_NONE { PUSH nat 2 ; FAILWITH } {} ;

                       PUSH mutez 1 ;

                       DIG 2 ;

                       MUL ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       SOME }

                     { DROP 3 ; NONE operation } } } } ;

       LAMBDA

         (pair nat nat)

         (pair nat nat)

         { UNPAIR ;

           DUP 2 ;

           DUP 2 ;

           ADD ;

           DUG 2 ;

           SUB ;

           DUP 2 ;

           DUP 3 ;

           MUL ;

           DUP ;

           MUL ;

           DUP ;

           MUL ;

           DIG 2 ;

           DUP 2 ;

           EDIV ;

           IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

           CAR ;

           DUP 3 ;

           DUP 4 ;

           MUL ;

           DUP ;

           MUL ;

           DUP ;

           MUL ;

           PUSH int 0 ;

           DUP 5 ;

           COMPARE ;

           EQ ;

           IF

             { DIG 3 ; DROP ; PUSH int 0 }

             { DIG 3 ; DUP 2 ; EDIV ; IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; CAR } ;

           SWAP ;

           DIG 3 ;

           SUB ;

           ISNAT ;

           IF_NONE { PUSH nat 13 ; FAILWITH } {} ;

           DUG 2 ;

           ADD ;

           ISNAT ;

           IF_NONE { PUSH nat 13 ; FAILWITH } {} ;

           PUSH nat 8 ;

           MUL ;

           SWAP ;

           PAIR } ;

       LAMBDA

         (pair nat nat)

         (pair nat nat)

         { UNPAIR ;

           DUP 2 ;

           DUP 2 ;

           ADD ;

           DUG 2 ;

           SUB ;

           DUP 2 ;

           DUP 3 ;

           MUL ;

           DUP ;

           DUP 2 ;

           DIG 2 ;

           MUL ;

           MUL ;

           DIG 2 ;

           DUP 2 ;

           EDIV ;

           IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

           CAR ;

           DUP 3 ;

           DUP 4 ;

           MUL ;

           DUP ;

           DUP 2 ;

           DIG 2 ;

           MUL ;

           MUL ;

           PUSH int 0 ;

           DUP 5 ;

           COMPARE ;

           EQ ;

           IF

             { DIG 3 ; DROP ; PUSH int 0 }

             { DIG 3 ; DUP 2 ; EDIV ; IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; CAR } ;

           SWAP ;

           DIG 3 ;

           SUB ;

           ISNAT ;

           IF_NONE { PUSH nat 13 ; FAILWITH } {} ;

           DUG 2 ;

           ADD ;

           ISNAT ;

           IF_NONE { PUSH nat 13 ; FAILWITH } {} ;

           PUSH nat 6 ;

           MUL ;

           SWAP ;

           PAIR } ;

       LAMBDA

         (pair nat nat)

         (pair nat nat)

         { UNPAIR ;

           DUP 2 ;

           DUP 2 ;

           ADD ;

           DUG 2 ;

           SUB ;

           DUP 2 ;

           DUP 3 ;

           MUL ;

           DUP ;

           DUP 2 ;

           MUL ;

           DIG 3 ;

           DIG 2 ;

           MUL ;

           DUP 3 ;

           DUP 4 ;

           MUL ;

           DUP ;

           DUP 2 ;

           MUL ;

           DIG 4 ;

           DIG 2 ;

           MUL ;

           SWAP ;

           DIG 3 ;

           SUB ;

           ISNAT ;

           IF_NONE { PUSH nat 13 ; FAILWITH } {} ;

           DUG 2 ;

           ADD ;

           ISNAT ;

           IF_NONE { PUSH nat 13 ; FAILWITH } {} ;

           PUSH nat 4 ;

           MUL ;

           SWAP ;

           PAIR } ;

       DIG 4 ;

       UNPAIR ;

       IF_LEFT

         { DIG 2 ;

           DIG 3 ;

           DIG 4 ;

           DIG 5 ;

           DROP 5 ;

           SELF_ADDRESS ;

           SENDER ;

           COMPARE ;

           NEQ ;

           SOURCE ;

           SENDER ;

           COMPARE ;

           NEQ ;

           AND ;

           IF

             { DROP ; PUSH nat 25 ; FAILWITH }

             { PUSH mutez 0 ;

               AMOUNT ;

               COMPARE ;

               GT ;

               IF

                 { DROP ; PUSH nat 24 ; FAILWITH }

                 { NIL operation ;

                   DUP 2 ;

                   GET 15 ;

                   ITER { CAR ;

                          IF_LEFT

                            { UNPAIR ;

                              SELF %set_fa2_balance ;

                              SWAP ;

                              CONTRACT %balance_of (pair (list (pair address nat))

                                                         (contract (list (pair

                                                                         (pair address

                                                                               nat)

                                                                         nat)))) ;

                              IF_NONE { PUSH nat 27 ; FAILWITH } {} ;

                              SWAP ;

                              NIL (pair address nat) ;

                              DIG 3 ;

                              SELF_ADDRESS ;

                              PAIR ;

                              CONS ;

                              PAIR ;

                              SWAP ;

                              PUSH mutez 0 ;

                              DIG 2 ;

                              TRANSFER_TOKENS ;

                              CONS }

                            { IF_LEFT

                                { SELF %set_fa1_balance ;

                                  SWAP ;

                                  CONTRACT %getBalance (pair address (contract nat)) ;

                                  IF_NONE { PUSH nat 26 ; FAILWITH } {} ;

                                  SWAP ;

                                  SELF_ADDRESS ;

                                  PAIR ;

                                  SWAP ;

                                  PUSH mutez 0 ;

                                  DIG 2 ;

                                  TRANSFER_TOKENS ;

                                  CONS }

                                { DROP } } } ;

                   PAIR } } }

         { IF_LEFT

             { DIG 2 ;

               DIG 3 ;

               DIG 4 ;

               DIG 5 ;

               DROP 4 ;

               SENDER ;

               LEFT unit ;

               RIGHT (pair address nat) ;

               DUP 3 ;

               GET 15 ;

               DUP 2 ;

               GET ;

               IF_NONE

                 { DROP 3 ; PUSH nat 30 ; FAILWITH }

                 { DUP 4 ;

                   DIG 4 ;

                   GET 15 ;

                   DIG 2 ;

                   DIG 4 ;

                   UPDATE 1 ;

                   SOME ;

                   DIG 3 ;

                   UPDATE ;

                   UPDATE 15 ;

                   NIL operation ;

                   PAIR } }

             { IF_LEFT

                 { DIG 2 ;

                   DIG 3 ;

                   DIG 4 ;

                   DIG 5 ;

                   DROP 4 ;

                   IF_CONS

                     { SWAP ; DROP ; DUP ; CDR ; DUP 2 ; CAR ; CDR ; DIG 2 ; CAR ; CAR ; PAIR 3 }

                     { PUSH nat 28 ; FAILWITH } ;

                   UNPAIR 3 ;

                   SELF_ADDRESS ;

                   SWAP ;

                   COMPARE ;

                   NEQ ;

                   IF

                     { DROP 3 ; PUSH nat 29 ; FAILWITH }

                     { SENDER ;

                       PAIR ;

                       LEFT (or address unit) ;

                       DUP 3 ;

                       GET 15 ;

                       DUP 2 ;

                       GET ;

                       IF_NONE

                         { DROP 3 ; PUSH nat 30 ; FAILWITH }

                         { DUP 4 ;

                           DIG 4 ;

                           GET 15 ;

                           DIG 2 ;

                           DIG 4 ;

                           UPDATE 1 ;

                           SOME ;

                           DIG 3 ;

                           UPDATE ;

                           UPDATE 15 ;

                           NIL operation ;

                           PAIR } } }

                 { IF_LEFT

                     { DIG 2 ;

                       DIG 3 ;

                       DIG 4 ;

                       DIG 5 ;

                       DROP 4 ;

                       DUP 2 ;

                       CAR ;

                       SENDER ;

                       GET ;

                       IF_NONE

                         { DROP 2 ; PUSH nat 12 ; FAILWITH }

                         { IF_LEFT

                             { DROP 3 ; PUSH nat 12 ; FAILWITH }

                             { DROP ; SWAP ; NIL operation ; DIG 2 ; SET_DELEGATE ; CONS ; PAIR } } }

                     { IF_LEFT

                         { DIG 2 ;

                           DIG 3 ;

                           DIG 4 ;

                           DIG 5 ;

                           DROP 4 ;

                           DUP 2 ;

                           CAR ;

                           SENDER ;

                           GET ;

                           IF_NONE

                             { DROP 2 ; PUSH nat 12 ; FAILWITH }

                             { IF_LEFT

                                 { DROP 3 ; PUSH nat 12 ; FAILWITH }

                                 { DROP ; UPDATE 18 ; NIL operation ; PAIR } } }

                         { IF_LEFT

                             { DIG 2 ;

                               DIG 3 ;

                               DIG 4 ;

                               DIG 5 ;

                               DROP 4 ;

                               DUP 2 ;

                               CAR ;

                               SENDER ;

                               GET ;

                               IF_NONE

                                 { DROP 2 ; PUSH nat 12 ; FAILWITH }

                                 { IF_LEFT

                                     { DROP 3 ; PUSH nat 12 ; FAILWITH }

                                     { DROP ; UPDATE 17 ; NIL operation ; PAIR } } }

                             { IF_LEFT

                                 { DIG 2 ;

                                   DIG 3 ;

                                   DIG 4 ;

                                   DIG 5 ;

                                   DROP 4 ;

                                   DUP 2 ;

                                   CAR ;

                                   SENDER ;

                                   GET ;

                                   IF_NONE

                                     { DROP 2 ; PUSH nat 12 ; FAILWITH }

                                     { IF_LEFT

                                         { DROP 3 ; PUSH nat 12 ; FAILWITH }

                                         { DROP ; UPDATE 7 ; NIL operation ; PAIR } } }

                                 { IF_LEFT

                                     { DIG 2 ;

                                       DIG 3 ;

                                       DIG 4 ;

                                       DIG 5 ;

                                       DROP 4 ;

                                       DUP 2 ;

                                       CAR ;

                                       SENDER ;

                                       GET ;

                                       IF_NONE

                                         { DROP 2 ; PUSH nat 12 ; FAILWITH }

                                         { IF_LEFT

                                             { DROP 3 ; PUSH nat 12 ; FAILWITH }

                                             { DROP ;

                                               DUP 2 ;

                                               DIG 2 ;

                                               CAR ;

                                               NONE (or unit unit) ;

                                               DIG 3 ;

                                               UPDATE ;

                                               UPDATE 1 ;

                                               NIL operation ;

                                               PAIR } } }

                                     { IF_LEFT

                                         { DIG 2 ;

                                           DIG 3 ;

                                           DIG 4 ;

                                           DIG 5 ;

                                           DROP 5 ;

                                           DUP ;

                                           CAR ;

                                           SENDER ;

                                           GET ;

                                           IF_NONE

                                             { DROP ; PUSH nat 16 ; FAILWITH }

                                             { IF_LEFT

                                                 { DROP ;

                                                   DUP ;

                                                   CAR ;

                                                   UNIT ;

                                                   RIGHT unit ;

                                                   SOME ;

                                                   SENDER ;

                                                   UPDATE ;

                                                   UPDATE 1 ;

                                                   NIL operation ;

                                                   PAIR }

                                                 { DROP 2 ; PUSH nat 17 ; FAILWITH } } }

                                         { IF_LEFT

                                             { DIG 2 ;

                                               DIG 3 ;

                                               DIG 4 ;

                                               DIG 5 ;

                                               DROP 4 ;

                                               DUP 2 ;

                                               CAR ;

                                               SENDER ;

                                               GET ;

                                               IF_NONE

                                                 { DROP 2 ; PUSH nat 12 ; FAILWITH }

                                                 { IF_LEFT

                                                     { DROP 3 ; PUSH nat 12 ; FAILWITH }

                                                     { DROP ;

                                                       DUP 2 ;

                                                       DIG 2 ;

                                                       CAR ;

                                                       UNIT ;

                                                       LEFT unit ;

                                                       SOME ;

                                                       DIG 3 ;

                                                       UPDATE ;

                                                       UPDATE 1 ;

                                                       NIL operation ;

                                                       PAIR } } }

                                             { IF_LEFT

                                                 { DIG 2 ;

                                                   DIG 3 ;

                                                   DIG 4 ;

                                                   DIG 5 ;

                                                   DROP 4 ;

                                                   DUP 2 ;

                                                   CAR ;

                                                   SENDER ;

                                                   GET ;

                                                   IF_NONE

                                                     { DROP 2 ; PUSH nat 12 ; FAILWITH }

                                                     { IF_LEFT

                                                         { DROP 3 ; PUSH nat 12 ; FAILWITH }

                                                         { DROP ;

                                                           UPDATE 13 ;

                                                           NIL operation ;

                                                           PAIR } } }

                                                 { IF_LEFT

                                                     { DIG 2 ;

                                                       DIG 3 ;

                                                       DIG 4 ;

                                                       DIG 5 ;

                                                       DROP 4 ;

                                                       DUP 2 ;

                                                       CAR ;

                                                       SENDER ;

                                                       GET ;

                                                       IF_NONE

                                                         { DROP 2 ; PUSH nat 12 ; FAILWITH }

                                                         { IF_LEFT

                                                             { DROP 3 ;

                                                               PUSH nat 12 ;

                                                               FAILWITH }

                                                             { DROP ;

                                                               UPDATE 11 ;

                                                               NIL operation ;

                                                               PAIR } } }

                                                     { IF_LEFT

                                                         { DIG 2 ;

                                                           DIG 3 ;

                                                           DIG 4 ;

                                                           DIG 5 ;

                                                           DROP 4 ;

                                                           DUP 2 ;

                                                           CAR ;

                                                           SENDER ;

                                                           GET ;

                                                           IF_NONE

                                                             { DROP 2 ;

                                                               PUSH nat 12 ;

                                                               FAILWITH }

                                                             { IF_LEFT

                                                                 { DROP 3 ;

                                                                   PUSH nat 12 ;

                                                                   FAILWITH }

                                                                 { DROP ;

                                                                   UPDATE 9 ;

                                                                   NIL operation ;

                                                                   PAIR } } }

                                                         { IF_LEFT

                                                             { DIG 2 ;

                                                               DIG 3 ;

                                                               DIG 4 ;

                                                               DIG 5 ;

                                                               DROP 4 ;

                                                               PUSH address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;

                                                               DUP 3 ;

                                                               GET 5 ;

                                                               COMPARE ;

                                                               NEQ ;

                                                               IF

                                                                 { DROP 2 ;

                                                                   PUSH nat 18 ;

                                                                   FAILWITH }

                                                                 { UPDATE 5 ;

                                                                   NIL operation ;

                                                                   PAIR } }

                                                             { IF_LEFT

                                                                 { UNPAIR ;

                                                                   UNPAIR 6 ;

                                                                   DIG 5 ;

                                                                   DROP ;

                                                                   SELF_ADDRESS ;

                                                                   SENDER ;

                                                                   COMPARE ;

                                                                   NEQ ;

                                                                   IF

                                                                     { DROP 11 ;

                                                                       PUSH nat 31 ;

                                                                       FAILWITH }

                                                                     { DUP 7 ;

                                                                       GET 15 ;

                                                                       DUP 2 ;

                                                                       GET ;

                                                                       IF_NONE

                                                                         { PUSH nat 21 ;

                                                                           FAILWITH }

                                                                         {} ;

                                                                       DUP 8 ;

                                                                       GET 15 ;

                                                                       DUP 4 ;

                                                                       GET ;

                                                                       IF_NONE

                                                                         { PUSH nat 21 ;

                                                                           FAILWITH }

                                                                         {} ;

                                                                       DUP 9 ;

                                                                       GET 17 ;

                                                                       DUP 5 ;

                                                                       DUP 5 ;

                                                                       PAIR ;

                                                                       VIEW

                                                                         "get_token_price"

                                                                         (pair nat nat) ;

                                                                       IF_NONE

                                                                         { PUSH nat 22 ;

                                                                           FAILWITH }

                                                                         {} ;

                                                                       UNPAIR ;

                                                                       DUP 4 ;

                                                                       CDR ;

                                                                       MUL ;

                                                                       SWAP ;

                                                                       DUP 3 ;

                                                                       CDR ;

                                                                       MUL ;

                                                                       DUP 11 ;

                                                                       GET 18 ;

                                                                       DUP 3 ;

                                                                       DUP 6 ;

                                                                       CAR ;

                                                                       MUL ;

                                                                       DUP 3 ;

                                                                       DUP 6 ;

                                                                       CAR ;

                                                                       MUL ;

                                                                       DUP 3 ;

                                                                       IF_LEFT

                                                                         { DROP ;

                                                                           DUP ;

                                                                           DUP 3 ;

                                                                           PAIR ;

                                                                           DUP 18 ;

                                                                           SWAP ;

                                                                           EXEC }

                                                                         { IF_LEFT

                                                                             { DROP ;

                                                                               DUP ;

                                                                               DUP 3 ;

                                                                               PAIR ;

                                                                               DUP 17 ;

                                                                               SWAP ;

                                                                               EXEC }

                                                                             { DROP ;

                                                                               DUP ;

                                                                               DUP 3 ;

                                                                               PAIR ;

                                                                               DUP 16 ;

                                                                               SWAP ;

                                                                               EXEC } } ;

                                                                       CAR ;

                                                                       DIG 4 ;

                                                                       DIG 4 ;

                                                                       PUSH int 5 ;

                                                                       DIG 3 ;

                                                                       PUSH nat 0 ;

                                                                       DIG 7 ;

                                                                       DUP 13 ;

                                                                       MUL ;

                                                                       DIG 6 ;

                                                                       DIG 7 ;

                                                                       PAIR 7 ;

                                                                       LEFT nat ;

                                                                       LOOP_LEFT { PUSH int 0 ;

                                                                                   DUP 2 ;

                                                                                   GET 11 ;

                                                                                   COMPARE ;

                                                                                   EQ ;

                                                                                   IF

                                                                                     { GET 7 ;

                                                                                       RIGHT (pair

                                                                                               nat

                                                                                               nat

                                                                                               nat

                                                                                               nat

                                                                                               nat

                                                                                               int

                                                                                               (or

                                                                                                 unit

                                                                                                 (or

                                                                                                   unit

                                                                                                   unit))) }

                                                                                     { DUP ;

                                                                                       GET 7 ;

                                                                                       DUP 2 ;

                                                                                       GET 3 ;

                                                                                       SUB ;

                                                                                       ISNAT ;

                                                                                       IF_NONE

                                                                                         { PUSH nat 13 ;

                                                                                           FAILWITH }

                                                                                         {} ;

                                                                                       DUP 2 ;