parameter (or (pair %init_token_sapling_pool (address %contract) (option %token_id nat))

              (list %default (pair (list %txns (sapling_transaction 8))

                                  (option %contract address)

                                  (option %token_id nat))));

storage (pair (sapling_state %tez 8) (map %token_fa_1_2 address (sapling_state 8))

              (map %token_fa_2 (pair address nat) (sapling_state 8)));

code { UNPAIR ;

       IF_LEFT

         { DUP 2 ;

           DUP 2 ;

           CDR ;

           IF_NONE

             { DUP 3 ;

               GET 3 ;

               DUP 3 ;

               CAR ;

               MEM ;

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

               DUP 2 ;

               CAR ;

               CONTRACT %transfer (pair (address %from_) (address %to_) (nat %value)) ;

               IF_NONE

                 { SWAP ; DIG 2 ; DROP 2 ; PUSH string "%TRANFER_DOESNT_EXIST" ; FAILWITH }

                 { DROP ;

                   DUP 2 ;

                   CAR ;

                   CONTRACT %approve (pair (address %spender) (nat %value)) ;

                   IF_NONE

                     { SWAP ; DIG 2 ; DROP 2 ; PUSH string "%APPROVE_DOESNT_EXIST" ; FAILWITH }

                     { DROP ;

                       DIG 2 ;

                       GET 3 ;

                       SAPLING_EMPTY_STATE 8 ;

                       DIG 3 ;

                       CAR ;

                       DUG 2 ;

                       SOME ;

                       DIG 2 ;

                       UPDATE ;

                       UPDATE 3 } } }

             { DUP 4 ;

               GET 4 ;

               DUP 2 ;

               DUP 5 ;

               CAR ;

               PAIR ;

               MEM ;

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

               DUP 3 ;

               CAR ;

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

                                             (list %txs (pair (address %to_)

                                                             (nat %token_id)

                                                             (nat %amount))))) ;

               IF_NONE

                 { DIG 2 ; DIG 3 ; DROP 3 ; PUSH string "%TRANFER_DOESNT_EXIST" ; FAILWITH }

                 { DROP ;

                   DUP 3 ;

                   CAR ;

                   CONTRACT %update_operators (list (or

                                                     (pair %add_operator

                                                       (address %owner)

                                                       (address %operator)

                                                       (nat %token_id))

                                                     (pair %remove_operator

                                                       (address %owner)

                                                       (address %operator)

                                                       (nat %token_id)))) ;

                   IF_NONE

                     { DIG 2 ;

                       DIG 3 ;

                       DROP 3 ;

                       PUSH string "%UPDATE_OPERATORS_DOESNT_EXIST" ;

                       FAILWITH }

                     { DROP ;

                       SWAP ;

                       DIG 3 ;

                       GET 4 ;

                       SAPLING_EMPTY_STATE 8 ;

                       DIG 3 ;

                       DIG 4 ;

                       CAR ;

                       PAIR ;

                       DUG 2 ;

                       SOME ;

                       DIG 2 ;

                       UPDATE ;

                       UPDATE 4 } } } ;

           NIL operation }

         { NIL operation ;

           DUG 2 ;

           ITER { UNPAIR 3 ;

                  SWAP ;

                  IF_NONE

                    { SWAP ;

                      DROP ;

                      DUP 2 ;

                      CAR ;

                      AMOUNT ;

                      SWAP ;

                      NIL operation ;

                      PAIR 3 ;

                      SWAP ;

                      LAMBDA

                        (pair (pair (list operation) (sapling_state 8) mutez)

                              (sapling_transaction 8))

                        (pair (list operation) (sapling_state 8) mutez)

                        { UNPAIR ;

                          UNPAIR 3 ;

                          SWAP ;

                          DIG 3 ;

                          SAPLING_VERIFY_UPDATE ;

                          IF_NONE

                            { DROP 2 ; PUSH string "INVALID_SAPLING_TX" ; FAILWITH }

                            { UNPAIR ;

                              SWAP ;

                              UNPAIR ;

                              DUP ;

                              ABS ;

                              PUSH mutez 1 ;

                              MUL ;

                              PUSH int 0 ;

                              DIG 2 ;

                              COMPARE ;

                              GT ;

                              IF

                                { DIG 2 ;

                                  UNPACK key_hash ;

                                  IF_NONE

                                    { DROP 4 ;

                                      PUSH string "UNABLE_TO_UNPACK_RECIPIENT" ;

                                      FAILWITH }

                                    { IMPLICIT_ACCOUNT ;

                                      SWAP ;

                                      UNIT ;

                                      TRANSFER_TOKENS ;

                                      DIG 3 ;

                                      DIG 2 ;

                                      NIL operation ;

                                      DIG 4 ;

                                      NIL operation ;

                                      SWAP ;

                                      ITER { CONS } ;

                                      ITER { CONS } ;

                                      DIG 3 ;

                                      CONS ;

                                      PAIR 3 } }

                                { DIG 4 ;

                                  SUB_MUTEZ ;

                                  IF_NONE

                                    { DROP 3 ; PUSH string "INVALID_AMOUNT" ; FAILWITH }

                                    { PUSH nat 0 ;

                                      DIG 3 ;

                                      SIZE ;

                                      COMPARE ;

                                      NEQ ;

                                      IF

                                        { PUSH string "UNEXPECTED_EMPTY_BOUND_DATA" ;

                                          FAILWITH }

                                        {} ;

                                      SWAP ;

                                      DIG 2 ;

                                      PAIR 3 } } } } ;

                      DUG 2 ;

                      ITER { SWAP ; PAIR ; DUP 2 ; SWAP ; EXEC } ;

                      SWAP ;

                      DROP ;

                      UNPAIR 3 ;

                      PUSH mutez 0 ;

                      DIG 3 ;

                      COMPARE ;

                      NEQ ;

                      IF

                        { DROP 2 ; PUSH string "UNEXPECTED_REMAINDER" ; FAILWITH }

                        { PAIR } ;

                      UNPAIR ;

                      DIG 3 ;

                      SWAP ;

                      LAMBDA

                        (pair (list operation) operation)

                        (list operation)

                        { UNPAIR ; SWAP ; CONS } ;

                      DUG 2 ;

                      ITER { SWAP ; PAIR ; DUP 2 ; SWAP ; EXEC } ;

                      SWAP ;

                      DROP ;

                      DUG 2 ;

                      UPDATE 1 }

                    { DIG 2 ;

                      IF_NONE

                        { DUP 3 ;

                          GET 3 ;

                          DUP 2 ;

                          GET ;

                          IF_NONE

                            { PUSH string "SAPLING_STATE_NOT_FOUND" ; FAILWITH }

                            {} ;

                          DUP 2 ;

                          SWAP ;

                          PAIR ;

                          PUSH mutez 0 ;

                          AMOUNT ;

                          COMPARE ;

                          GT ;

                          IF

                            { DIG 2 ; DROP 2 ; PUSH string "UNEXPECTED_XTZ_AMOUNT" ; FAILWITH }

                            { DUP ;

                              CDR ;

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

                                                       (nat %value)) ;

                              IF_NONE

                                { DIG 2 ;

                                  DROP 2 ;

                                  PUSH string "%TRANSFER_DOESNT_EXIST" ;

                                  FAILWITH }

                                { SWAP ;

                                  NIL operation ;

                                  PAIR ;

                                  DIG 3 ;

                                  ITER { SWAP ;

                                         UNPAIR ;

                                         DUP 2 ;

                                         CAR ;

                                         DIG 3 ;

                                         SAPLING_VERIFY_UPDATE ;

                                         IF_NONE

                                           { DROP 2 ;

                                             PUSH string "INVALID_SAPLING_TX" ;

                                             FAILWITH }

                                           { UNPAIR ;

                                             SWAP ;

                                             UNPAIR ;

                                             PUSH int 0 ;

                                             DUP 2 ;

                                             COMPARE ;

                                             GT ;

                                             IF

                                               { DIG 2 ;

                                                 UNPACK key_hash ;

                                                 IF_NONE

                                                   { DROP 4 ;

                                                     PUSH string "UNABLE_TO_UNPACK_RECIPIENT" ;

                                                     FAILWITH }

                                                   { IMPLICIT_ACCOUNT ;

                                                     ADDRESS ;

                                                     SWAP ;

                                                     ABS ;

                                                     SWAP ;

                                                     SELF_ADDRESS ;

                                                     PAIR 3 ;

                                                     DIG 3 ;

                                                     DIG 2 ;

                                                     UPDATE 1 ;

                                                     NIL operation ;

                                                     DIG 3 ;

                                                     NIL operation ;

                                                     SWAP ;

                                                     ITER { CONS } ;

                                                     ITER { CONS } ;

                                                     DUP 4 ;

                                                     PUSH mutez 0 ;

                                                     DIG 4 ;

                                                     TRANSFER_TOKENS ;

                                                     CONS ;

                                                     PAIR } }

                                               { DIG 2 ;

                                                 UNPACK key_hash ;

                                                 IF_NONE

                                                   { PUSH int 0 ;

                                                     DUP 2 ;

                                                     COMPARE ;

                                                     LT ;

                                                     IF

                                                       { ABS ;

                                                         SELF_ADDRESS ;

                                                         SENDER ;

                                                         PAIR 3 ;

                                                         DIG 3 ;

                                                         DIG 2 ;

                                                         UPDATE 1 ;

                                                         NIL operation ;

                                                         DIG 3 ;

                                                         NIL operation ;

                                                         SWAP ;

                                                         ITER { CONS } ;

                                                         ITER { CONS } ;

                                                         DUP 4 ;

                                                         PUSH mutez 0 ;

                                                         DIG 4 ;

                                                         TRANSFER_TOKENS ;

                                                         CONS }

                                                       { DROP ; DIG 2 ; SWAP ; UPDATE 1 ; SWAP } ;

                                                     PAIR }

                                                   { DROP 5 ;

                                                     PUSH string "UNEXPECTED_RECIPIENT" ;

                                                     FAILWITH } } } } ;

                                  SWAP ;

                                  DROP } } ;

                          UNPAIR ;

                          DIG 4 ;

                          SWAP ;

                          LAMBDA

                            (pair (list operation) operation)

                            (list operation)

                            { UNPAIR ; SWAP ; CONS } ;

                          DUG 2 ;

                          ITER { SWAP ; PAIR ; DUP 2 ; SWAP ; EXEC } ;

                          SWAP ;

                          DROP ;

                          DUG 3 ;

                          DUP 3 ;

                          DIG 3 ;

                          GET 3 ;

                          DIG 2 ;

                          CAR ;

                          SOME ;

                          DIG 3 ;

                          UPDATE ;

                          UPDATE 3 }

                        { DUP 4 ;

                          GET 4 ;

                          DUP 2 ;

                          DUP 4 ;

                          PAIR ;

                          GET ;

                          IF_NONE

                            { PUSH string "SAPLING_STATE_NOT_FOUND" ; FAILWITH }

                            {} ;

                          DUP 2 ;

                          DUP 4 ;

                          DIG 2 ;

                          PAIR 3 ;

                          PUSH mutez 0 ;

                          AMOUNT ;

                          COMPARE ;

                          GT ;

                          IF

                            { DIG 3 ; DROP 2 ; PUSH string "UNEXPECTED_XTZ_AMOUNT" ; FAILWITH }

                            { DUP ;

                              PUSH nat 0 ;

                              NIL (pair address nat) ;

                              PAIR 3 ;

                              DIG 4 ;

                              ITER { SWAP ;

                                     UNPAIR 3 ;

                                     DUP 3 ;

                                     CAR ;

                                     DIG 4 ;

                                     SAPLING_VERIFY_UPDATE ;

                                     IF_NONE

                                       { DROP 3 ;

                                         PUSH string "INVALID_SAPLING_TX" ;

                                         FAILWITH }

                                       { UNPAIR ;

                                         SWAP ;

                                         UNPAIR ;

                                         PUSH int 0 ;

                                         DUP 2 ;

                                         COMPARE ;

                                         GT ;

                                         IF

                                           { DIG 2 ;

                                             UNPACK key_hash ;

                                             IF_NONE

                                               { DROP 5 ;

                                                 PUSH string "UNABLE_TO_UNPACK_RECIPIENT" ;

                                                 FAILWITH }

                                               { IMPLICIT_ACCOUNT ;

                                                 ADDRESS ;

                                                 SWAP ;

                                                 ABS ;

                                                 SWAP ;

                                                 PAIR ;

                                                 DIG 4 ;

                                                 DIG 2 ;

                                                 UPDATE 1 ;

                                                 DIG 3 ;

                                                 NIL (pair address nat) ;

                                                 DIG 4 ;

                                                 NIL (pair address nat) ;

                                                 SWAP ;

                                                 ITER { CONS } ;

                                                 ITER { CONS } ;

                                                 DIG 3 ;

                                                 CONS ;

                                                 PAIR 3 } }

                                           { PUSH int 0 ;

                                             DUP 2 ;

                                             COMPARE ;

                                             LT ;

                                             IF

                                               { DIG 2 ;

                                                 UNPACK key_hash ;

                                                 IF_NONE

                                                   { DIG 4 ;

                                                     DIG 2 ;

                                                     UPDATE 1 ;

                                                     SWAP ;

                                                     ABS ;

                                                     DIG 3 ;

                                                     ADD ;

                                                     DIG 2 ;

                                                     PAIR 3 }

                                                   { DROP 6 ;

                                                     PUSH string "UNEXPECTED_RECIPIENT" ;

                                                     FAILWITH } }

                                               { DIG 2 ;

                                                 DROP 2 ;

                                                 DIG 3 ;

                                                 SWAP ;

                                                 UPDATE 1 ;

                                                 DUG 2 ;

                                                 PAIR 3 } } } } ;

                              UNPAIR 3 ;

                              PUSH nat 0 ;

                              DUP 3 ;

                              COMPARE ;

                              EQ ;

                              PUSH nat 0 ;

                              DUP 3 ;

                              SIZE ;

                              COMPARE ;

                              EQ ;

                              AND ;

                              IF

                                { SWAP ; DIG 3 ; DROP 3 ; NIL operation }

                                { DUP 4 ;

                                  GET 3 ;

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

                                                                (list %txs (pair

                                                                            (address %to_)

                                                                            (nat %token_id)

                                                                            (nat %amount))))) ;

                                  IF_NONE

                                    { SWAP ;

                                      DIG 3 ;

                                      DROP 3 ;

                                      PUSH string "%TRANFER_DOESNT_EXIST" ;

                                      FAILWITH }

                                    { PUSH nat 0 ;

                                      DUP 4 ;

                                      COMPARE ;

                                      GT ;

                                      IF

                                        { NIL (pair address

                                                    (list (pair address nat nat))) ;

                                          NIL (pair address nat nat) ;

                                          DIG 4 ;

                                          DUP 7 ;

                                          GET 4 ;

                                          SELF_ADDRESS ;

                                          PAIR 3 ;

                                          CONS ;

                                          SENDER ;

                                          PAIR ;

                                          CONS }

                                        { DIG 2 ;

                                          DROP ;

                                          NIL (pair address

                                                    (list (pair address nat nat))) } ;

                                      DIG 2 ;

                                      MAP { DUP ; CDR ; DUP 6 ; GET 4 ; DIG 2 ; CAR ; PAIR 3 } ;

                                      DIG 4 ;

                                      DROP ;

                                      PUSH nat 0 ;

                                      DUP 2 ;

                                      SIZE ;

                                      COMPARE ;

                                      NEQ ;

                                      IF

                                        { NIL (pair address

                                                    (list (pair address nat nat))) ;

                                          DIG 2 ;

                                          NIL (pair address

                                                    (list (pair address nat nat))) ;

                                          SWAP ;

                                          ITER { CONS } ;

                                          ITER { CONS } ;

                                          SWAP ;

                                          SELF_ADDRESS ;

                                          PAIR ;

                                          CONS }

                                        { DROP } ;

                                      SWAP ;

                                      PUSH mutez 0 ;

                                      DIG 2 ;

                                      TRANSFER_TOKENS } ;

                                  SWAP ;

                                  NIL operation ;

                                  DIG 2 ;

                                  CONS } ;

                              PAIR } ;

                          UNPAIR ;

                          DIG 5 ;

                          SWAP ;

                          LAMBDA

                            (pair (list operation) operation)

                            (list operation)

                            { UNPAIR ; SWAP ; CONS } ;

                          DUG 2 ;

                          ITER { SWAP ; PAIR ; DUP 2 ; SWAP ; EXEC } ;

                          SWAP ;

                          DROP ;

                          DUG 4 ;

                          DUP 4 ;

                          DIG 4 ;

                          GET 4 ;

                          DIG 2 ;

                          CAR ;

                          SOME ;

                          DIG 3 ;

                          DIG 4 ;

                          PAIR ;

                          UPDATE ;

                          UPDATE 4 } } } ;

           SWAP } ;

       PAIR }