parameter (or

            (or (pair %cancel (map key_hash signature) (pair chain_id (pair nat nat)))

                (nat %execute))

            (or

              (pair %rotate (map key_hash signature)

                            (pair chain_id (pair nat (pair nat (list key)))))

              (pair %submit (map key_hash signature)

                            (pair chain_id (pair nat (lambda unit (list operation)))))));

storage (pair (pair (nat %operationId) (list %signers key))

              (pair (nat %threshold)

                    (pair

                      (big_map %timelock nat

                                         (pair timestamp (lambda unit (list operation))))

                      (nat %timelockSeconds))));

code { DUP ;

       CDR ;

       SWAP ;

       CAR ;

       IF_LEFT

         { IF_LEFT

             { DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               CHAIN_ID ;

               PACK ;

               DIG 4 ;

               DUP ;

               DUG 5 ;

               PACK ;

               COMPARE ;

               EQ ;

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

               PUSH nat 1 ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CAR ;

               CAR ;

               ADD ;

               DIG 2 ;

               DUP ;

               DUG 3 ;

               COMPARE ;

               EQ ;

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

               PUSH nat 0 ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CAR ;

               CDR ;

               ITER { DIG 7 ;

                      DUP ;

                      DUG 8 ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      HASH_KEY ;

                      MEM ;

                      IF

                        { DIG 6 ;

                          DUP ;

                          DUG 7 ;

                          PACK ;

                          DIG 8 ;

                          DUP ;

                          DUG 9 ;

                          DIG 2 ;

                          DUP ;

                          DUG 3 ;

                          HASH_KEY ;

                          GET ;

                          { IF_NONE { PUSH int 196 ; FAILWITH } {} } ;

                          DIG 2 ;

                          CHECK_SIGNATURE ;

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

                          PUSH nat 1 ;

                          ADD }

                        { DROP } } ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CDR ;

               CAR ;

               SWAP ;

               COMPARE ;

               GE ;

               IF

                 { SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP }

                 { PUSH string "TOO_FEW_SIGS" ; FAILWITH } ;

               SWAP ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               PUSH nat 1 ;

               ADD ;

               PAIR ;

               PAIR ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               NONE (pair timestamp (lambda unit (list operation))) ;

               DIG 5 ;

               UPDATE ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               NIL operation }

             { SWAP ;

               DUP ;

               DUG 2 ;

               CDR ;

               CDR ;

               CAR ;

               SWAP ;

               DUP ;

               DUG 2 ;

               GET ;

               { IF_NONE { PUSH int 214 ; FAILWITH } {} } ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               NOW ;

               DIG 2 ;

               DUP ;

               DUG 3 ;

               DIG 5 ;

               DUP ;

               DUG 6 ;

               CDR ;

               CDR ;

               CDR ;

               INT ;

               ADD ;

               COMPARE ;

               LT ;

               IF { SWAP ; DROP } { PUSH string "TOO_EARLY" ; FAILWITH } ;

               DIG 2 ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               NONE (pair timestamp (lambda unit (list operation))) ;

               DIG 6 ;

               UPDATE ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               NIL operation ;

               SWAP ;

               UNIT ;

               EXEC ;

               ITER { CONS } } }

         { IF_LEFT

             { DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               CHAIN_ID ;

               PACK ;

               DIG 4 ;

               DUP ;

               DUG 5 ;

               PACK ;

               COMPARE ;

               EQ ;

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

               PUSH nat 1 ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CAR ;

               CAR ;

               ADD ;

               DIG 2 ;

               DUP ;

               DUG 3 ;

               COMPARE ;

               EQ ;

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

               PUSH nat 0 ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CAR ;

               CDR ;

               ITER { DIG 7 ;

                      DUP ;

                      DUG 8 ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      HASH_KEY ;

                      MEM ;

                      IF

                        { DIG 6 ;

                          DUP ;

                          DUG 7 ;

                          PACK ;

                          DIG 8 ;

                          DUP ;

                          DUG 9 ;

                          DIG 2 ;

                          DUP ;

                          DUG 3 ;

                          HASH_KEY ;

                          GET ;

                          { IF_NONE { PUSH int 157 ; FAILWITH } {} } ;

                          DIG 2 ;

                          CHECK_SIGNATURE ;

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

                          PUSH nat 1 ;

                          ADD }

                        { DROP } } ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CDR ;

               CAR ;

               SWAP ;

               COMPARE ;

               GE ;

               IF

                 { SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP }

                 { PUSH string "TOO_FEW_SIGS" ; FAILWITH } ;

               SWAP ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               PUSH nat 1 ;

               ADD ;

               PAIR ;

               PAIR ;

               SWAP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DIG 2 ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               CDR ;

               DIG 3 ;

               PAIR ;

               SWAP ;

               PAIR ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               CAR ;

               DIG 2 ;

               SWAP ;

               PAIR ;

               PAIR }

             { DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               CHAIN_ID ;

               PACK ;

               DIG 4 ;

               DUP ;

               DUG 5 ;

               PACK ;

               COMPARE ;

               EQ ;

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

               PUSH nat 1 ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CAR ;

               CAR ;

               ADD ;

               DIG 2 ;

               DUP ;

               DUG 3 ;

               COMPARE ;

               EQ ;

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

               PUSH nat 0 ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CAR ;

               CDR ;

               ITER { DIG 7 ;

                      DUP ;

                      DUG 8 ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      HASH_KEY ;

                      MEM ;

                      IF

                        { DIG 6 ;

                          DUP ;

                          DUG 7 ;

                          PACK ;

                          DIG 8 ;

                          DUP ;

                          DUG 9 ;

                          DIG 2 ;

                          DUP ;

                          DUG 3 ;

                          HASH_KEY ;

                          GET ;

                          { IF_NONE { PUSH int 120 ; FAILWITH } {} } ;

                          DIG 2 ;

                          CHECK_SIGNATURE ;

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

                          PUSH nat 1 ;

                          ADD }

                        { DROP } } ;

               DIG 8 ;

               DUP ;

               DUG 9 ;

               CDR ;

               CAR ;

               SWAP ;

               COMPARE ;

               GE ;

               IF

                 { SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP }

                 { PUSH string "TOO_FEW_SIGS" ; FAILWITH } ;

               SWAP ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               PUSH nat 1 ;

               ADD ;

               PAIR ;

               PAIR ;

               DUP ;

               DUG 2 ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               CAR ;

               SWAP ;

               CDR ;

               DUP ;

               CDR ;

               SWAP ;

               CAR ;

               DIG 5 ;

               CAR ;

               CAR ;

               DIG 5 ;

               NOW ;

               PAIR ;

               SOME ;

               SWAP ;

               UPDATE ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR } ;

           NIL operation } ;

       NIL operation ;

       SWAP ;

       ITER { CONS } ;

       PAIR }