parameter (or

            (or

              (or (address %add_receiver)

                  (or (unit %default) (lambda %execute unit (list operation))))

              (or

                (pair %forward_to_receiver (nat %amount)

                                           (pair (address %receiver)

                                                 (or %transfer_type (address %fa12)

                                                                    (or

                                                                      (pair %fa2

                                                                        (address %contract)

                                                                        (nat %token_id))

                                                                      (unit %tez)))))

                (or (address %propose_administrator) (address %remove_administrator))))

            (or

              (or

                (pair %remove_exchange

                  (or %src_token (address %fa12)

                                 (or (pair %fa2 (address %contract) (nat %token_id))

                                     (unit %tez)))

                  (or %dst_token (address %fa12)

                                 (or (pair %fa2 (address %contract) (nat %token_id))

                                     (unit %tez))))

                (or (address %remove_receiver) (unit %set_administrator)))

              (or

                (pair %set_exchange

                  (pair %exchange_key

                    (or %src_token (address %fa12)

                                   (or (pair %fa2 (address %contract) (nat %token_id))

                                       (unit %tez)))

                    (or %dst_token (address %fa12)

                                   (or (pair %fa2 (address %contract) (nat %token_id))

                                       (unit %tez))))

                  (pair %exchange_value (address %oracle)

                                        (lambda %exchange_lambda (pair nat nat)

                                                                 (list operation))))

                (or

                  (list %swap (pair

                               (pair %exchange_key

                                 (or %src_token (address %fa12)

                                                (or

                                                  (pair %fa2 (address %contract)

                                                             (nat %token_id))

                                                  (unit %tez)))

                                 (or %dst_token (address %fa12)

                                                (or

                                                  (pair %fa2 (address %contract)

                                                             (nat %token_id))

                                                  (unit %tez))))

                               (nat %token_amount)))

                  (pair %update_trading_window (timestamp %initial_shift)

                                               (pair (nat %duration_in_seconds)

                                                     (nat %recurrence_in_seconds)))))));

storage (pair

          (pair (big_map %administrators address nat)

                (big_map %allowed_funds_receivers address unit))

          (pair

            (big_map %exchanges

              (pair

                (or %src_token (address %fa12)

                               (or (pair %fa2 (address %contract) (nat %token_id))

                                   (unit %tez)))

                (or %dst_token (address %fa12)

                               (or (pair %fa2 (address %contract) (nat %token_id))

                                   (unit %tez))))

              (pair (address %oracle)

                    (lambda %exchange_lambda (pair nat nat) (list operation))))

            (pair %trading_window (timestamp %initial_shift)

                                  (pair (nat %duration_in_seconds)

                                        (nat %recurrence_in_seconds)))));

code { LAMBDA

         (pair unit

               (pair (pair (big_map address nat) (big_map address unit))

                     (pair

                       (big_map

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

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

                         (pair address (lambda (pair nat nat) (list operation))))

                       (pair timestamp (pair nat nat)))))

         (pair unit

               (pair (pair (big_map address nat) (big_map address unit))

                     (pair

                       (big_map

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

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

                         (pair address (lambda (pair nat nat) (list operation))))

                       (pair timestamp (pair nat nat)))))

         { CDR ;

           DUP ;

           CAR ;

           CAR ;

           PUSH nat 1 ;

           SWAP ;

           SENDER ;

           GET ;

           IF_NONE { PUSH int 21 ; FAILWITH } {} ;

           COMPARE ;

           EQ ;

           IF {} { PUSH int 401 ; FAILWITH } ;

           UNIT ;

           PAIR } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   DIG 2 ;

                   UNIT ;

                   SWAP ;

                   DIG 3 ;

                   DIG 2 ;

                   PAIR ;

                   EXEC ;

                   CDR ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   PUSH (option unit) (Some Unit) ;

                   DIG 4 ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   NIL operation }

                 { IF_LEFT

                     { DROP ; SWAP ; DROP ; NIL operation }

                     { AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       DIG 2 ;

                       UNIT ;

                       SWAP ;

                       DIG 3 ;

                       DIG 2 ;

                       PAIR ;

                       EXEC ;

                       CDR ;

                       SWAP ;

                       NIL operation ;

                       SWAP ;

                       UNIT ;

                       EXEC ;

                       NIL operation ;

                       SWAP ;

                       ITER { CONS } ;

                       ITER { CONS } } } }

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   GET 3 ;

                   MEM ;

                   IF {} { PUSH string "RECEIVER_NOT_ALLOWED" ; FAILWITH } ;

                   DUP ;

                   GET 4 ;

                   IF_LEFT

                     { PUSH nat 0 ;

                       DUP 3 ;

                       CAR ;

                       COMPARE ;

                       GT ;

                       IF

                         { CONTRACT %transfer (pair (address %from)

                                                    (pair (address %to) (nat %value))) ;

                           IF_NONE { PUSH int 19 ; FAILWITH } {} ;

                           NIL operation ;

                           SWAP ;

                           PUSH mutez 0 ;

                           DIG 3 ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           GET 3 ;

                           SELF_ADDRESS ;

                           PAIR 3 ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { DROP 2 ; NIL operation } }

                     { IF_LEFT

                         { PUSH nat 0 ;

                           DUP 3 ;

                           CAR ;

                           COMPARE ;

                           GT ;

                           IF

                             { DUP ;

                               CAR ;

                               CONTRACT %transfer (list (pair (address %from_)

                                                             (list %txs (pair

                                                                         (address %to_)

                                                                         (pair

                                                                           (nat %token_id)

                                                                           (nat %amount)))))) ;

                               IF_NONE { PUSH int 36 ; FAILWITH } {} ;

                               NIL operation ;

                               SWAP ;

                               PUSH mutez 0 ;

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

                               NIL (pair address (pair nat nat)) ;

                               DUP 7 ;

                               CAR ;

                               DIG 6 ;

                               CDR ;

                               DIG 7 ;

                               GET 3 ;

                               PAIR 3 ;

                               CONS ;

                               SELF_ADDRESS ;

                               PAIR ;

                               CONS ;

                               TRANSFER_TOKENS ;

                               CONS }

                             { DROP 2 ; NIL operation } }

                         { DROP ;

                           DUP ;

                           CAR ;

                           PUSH mutez 1 ;

                           SWAP ;

                           MUL ;

                           NIL operation ;

                           DIG 2 ;

                           GET 3 ;

                           CONTRACT unit ;

                           IF_NONE { PUSH int 82 ; FAILWITH } {} ;

                           DIG 2 ;

                           UNIT ;

                           TRANSFER_TOKENS ;

                           CONS } } }

                 { IF_LEFT

                     { AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       DIG 2 ;

                       UNIT ;

                       SWAP ;

                       DIG 3 ;

                       DIG 2 ;

                       PAIR ;

                       EXEC ;

                       CDR ;

                       UNPAIR ;

                       UNPAIR ;

                       PUSH (option nat) (Some 0) ;

                       DIG 4 ;

                       UPDATE ;

                       PAIR ;

                       PAIR }

                     { AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       DIG 2 ;

                       UNIT ;

                       SWAP ;

                       DIG 3 ;

                       DIG 2 ;

                       PAIR ;

                       EXEC ;

                       CDR ;

                       UNPAIR ;

                       UNPAIR ;

                       NONE nat ;

                       DIG 4 ;

                       UPDATE ;

                       PAIR ;

                       PAIR } ;

                   NIL operation } } }

         { IF_LEFT

             { IF_LEFT

                 { AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   DIG 2 ;

                   UNIT ;

                   SWAP ;

                   DIG 3 ;

                   DIG 2 ;

                   PAIR ;

                   EXEC ;

                   CDR ;

                   DUP ;

                   GET 3 ;

                   NONE (pair address (lambda (pair nat nat) (list operation))) ;

                   DIG 3 ;

                   UPDATE ;

                   UPDATE 3 }

                 { IF_LEFT

                     { AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       DIG 2 ;

                       UNIT ;

                       SWAP ;

                       DIG 3 ;

                       DIG 2 ;

                       PAIR ;

                       EXEC ;

                       CDR ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       NONE unit ;

                       DIG 4 ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR }

                     { DROP ;

                       SWAP ;

                       DROP ;

                       AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       DUP ;

                       CAR ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 46 ; FAILWITH } {} ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 405 ; FAILWITH } ;

                       UNPAIR ;

                       UNPAIR ;

                       PUSH (option nat) (Some 1) ;

                       SENDER ;

                       UPDATE ;

                       PAIR ;

                       PAIR } } ;

               NIL operation }

             { IF_LEFT

                 { AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   DIG 2 ;

                   UNIT ;

                   SWAP ;

                   DIG 3 ;

                   DIG 2 ;

                   PAIR ;

                   EXEC ;

                   CDR ;

                   DUP ;

                   GET 3 ;

                   DUP 3 ;

                   CDR ;

                   SOME ;

                   DIG 3 ;

                   CAR ;

                   UPDATE ;

                   UPDATE 3 ;

                   NIL operation }

                 { IF_LEFT

                     { AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       GET 7 ;

                       SWAP ;

                       DUP ;

                       GET 8 ;

                       SWAP ;

                       DUP ;

                       DUG 4 ;

                       GET 5 ;

                       NOW ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 75 ; FAILWITH } {} ;

                       EDIV ;

                       IF_NONE { PUSH int 76 ; FAILWITH } { CDR } ;

                       COMPARE ;

                       LE ;

                       IF {} { PUSH int 505 ; FAILWITH } ;

                       DUP ;

                       NIL operation ;

                       SWAP ;

                       ITER { DUP 4 ;

                              GET 3 ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              CAR ;

                              MEM ;

                              IF

                                {}

                                { PUSH string "WrongCondition: self.data.exchanges.contains(exchange.exchange_key)" ;

                                  FAILWITH } ;

                              DUP 4 ;

                              GET 3 ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              CAR ;

                              GET ;

                              IF_NONE { PUSH int 85 ; FAILWITH } {} ;

                              CDR ;

                              DUP 5 ;

                              GET 3 ;

                              DUP 3 ;

                              CAR ;

                              GET ;

                              IF_NONE { PUSH int 85 ; FAILWITH } {} ;

                              CAR ;

                              DUP 3 ;

                              CDR ;

                              VIEW "get_min_out" nat ;

                              IF_NONE { PUSH int 86 ; FAILWITH } {} ;

                              DUP 3 ;

                              CDR ;

                              PAIR ;

                              EXEC ;

                              NIL operation ;

                              SWAP ;

                              ITER { CONS } ;

                              ITER { DIG 2 ; SWAP ; CONS ; SWAP } ;

                              DROP } ;

                       SWAP ;

                       DROP ;

                       DIG 2 ;

                       DROP }

                     { AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       DUP ;

                       CAR ;

                       NOW ;

                       COMPARE ;

                       GT ;

                       IF {} { PUSH int 506 ; FAILWITH } ;

                       DUP ;

                       GET 4 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       COMPARE ;

                       LT ;

                       IF {} { PUSH int 506 ; FAILWITH } ;

                       DIG 2 ;

                       UNIT ;

                       SWAP ;

                       DIG 3 ;

                       DIG 2 ;

                       PAIR ;

                       EXEC ;

                       CDR ;

                       SWAP ;

                       UPDATE 4 ;

                       NIL operation } } } } ;

       NIL operation ;

       SWAP ;

       ITER { CONS } ;

       PAIR }