{ parameter (or

              (or

                (or (or (unit %confirmAdmin) (unit %default))

                    (or

                      (pair %flip (pair %asset address nat) (nat %amount) (bool %heads))

                      (nat %push)))

                (or (or (option %setAdmin address) (address %setOracle))

                    (or (bool %setPause)

                        (pair %updateAssets (pair address nat)

                                            (pair (nat %minbet) (nat %balance)

                                                  (bool %fa2)

                                                  (nat %flipped)

                                                  (nat %shared)

                                                  (address %dest))))))

              (pair %withdraw (pair %asset address nat) (nat %amount) (address %target))) ;

  storage (pair

            (pair

              (pair

                (pair (address %admin)

                      (map %assets (pair address nat)

                                   (pair (nat %minbet) (nat %balance) (bool %fa2)

                                         (nat %flipped)

                                         (nat %shared)

                                         (address %dest))))

                (pair (nat %fee)

                      (big_map %games nat

                                      (pair (nat %amount) (pair %asset address nat)

                                            (bool %heads)

                                            (address %player)

                                            (nat %status)

                                            (timestamp %ts)))))

              (pair (pair (nat %gamesPlayed) (nat %lock))

                    (pair (address %oracle) (bool %paused))))

            (pair (pair (option %pending address) (big_map %players address nat))

                  (pair (nat %processed) (nat %threshold)))) ;

  code { NIL operation ;

         PUSH string "I don't know you" ;

         LAMBDA

           (pair (pair address (list (pair address nat)))

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

           (list operation)

           { UNPAIR ;

             UNPAIR ;

             DIG 2 ;

             UNPAIR ;

             PUSH string "Bad FA1.2 contract" ;

             SWAP ;

             CAR ;

             CONTRACT %transfer (pair (address %from) (pair (address %to) (nat %value))) ;

             IF_NONE { FAILWITH } { SWAP ; DROP } ;

             SWAP ;

             DIG 3 ;

             ITER { SWAP ; DUP 3 ; PUSH mutez 0 ; DIG 3 ; DUP 6 ; PAIR ; TRANSFER_TOKENS ; CONS } ;

             SWAP ;

             DIG 2 ;

             DROP 2 } ;

         LAMBDA

           (pair (pair address (list (pair address nat)))

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

           (list operation)

           { UNPAIR ;

             UNPAIR ;

             DIG 2 ;

             UNPAIR ;

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

             DIG 4 ;

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

             DIG 4 ;

             PAIR ;

             CONS ;

             DIG 2 ;

             PUSH string "Bad FA2 contract" ;

             DIG 3 ;

             CAR ;

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

                                           (list %txs (pair (address %to_)

                                                           (nat %token_id)

                                                           (nat %amount))))) ;

             IF_NONE { FAILWITH } { SWAP ; DROP } ;

             PUSH mutez 0 ;

             DIG 3 ;

             TRANSFER_TOKENS ;

             CONS } ;

         DIG 4 ;

         UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { DIG 2 ;

                     DIG 3 ;

                     DROP 2 ;

                     IF_LEFT

                       { DROP ;

                         DUP ;

                         DUG 2 ;

                         CDR ;

                         CAR ;

                         CAR ;

                         SENDER ;

                         SOME ;

                         COMPARE ;

                         EQ ;

                         IF { DROP } { FAILWITH } ;

                         DUP ;

                         CDR ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 3 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         SENDER ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         DUP ;

                         CDR ;

                         CDR ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         NONE address ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         CAR ;

                         PAIR ;

                         SWAP ;

                         PAIR }

                       { DIG 2 ; DROP 2 ; SWAP ; PAIR } }

                   { DIG 4 ;

                     DROP ;

                     IF_LEFT

                       { PUSH string "Contract is paused" ;

                         PUSH bool False ;

                         DUP 4 ;

                         CAR ;

                         CDR ;

                         CDR ;

                         CDR ;

                         COMPARE ;

                         EQ ;

                         IF { DROP } { FAILWITH } ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         PUSH string "Unknown asset requested" ;

                         DIG 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 2 ;

                         GET ;

                         IF_NONE { FAILWITH } { SWAP ; DROP } ;

                         PUSH string "Bid not accepted" ;

                         SOURCE ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         IF { DROP } { FAILWITH } ;

                         PUSH string "Bet is too low" ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         DUP 4 ;

                         GET 3 ;

                         COMPARE ;

                         GE ;

                         IF { DROP } { FAILWITH } ;

                         PUSH string "Bet is too high for this balance" ;

                         DUP 4 ;

                         CDR ;

                         CDR ;

                         CDR ;

                         DUP 3 ;

                         GET 3 ;

                         EDIV ;

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

                         CAR ;

                         DUP 4 ;

                         GET 3 ;

                         COMPARE ;

                         LE ;

                         IF { DROP } { FAILWITH } ;

                         DUP 3 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         SENDER ;

                         GET ;

                         IF_NONE

                           { UNIT }

                           { LEVEL ;

                             SWAP ;

                             COMPARE ;

                             EQ ;

                             IF { PUSH string "Robot, huh?" ; FAILWITH } { UNIT } } ;

                         DROP ;

                         DUP 3 ;

                         CDR ;

                         CDR ;

                         DUP 4 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         LEVEL ;

                         SOME ;

                         SENDER ;

                         UPDATE ;

                         DUP 5 ;

                         CDR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         DIG 3 ;

                         CAR ;

                         PAIR ;

                         DUP ;

                         CDR ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         CDR ;

                         NOW ;

                         PUSH nat 0 ;

                         SENDER ;

                         DUP 9 ;

                         GET 4 ;

                         DUP 10 ;

                         CAR ;

                         DUP 11 ;

                         GET 3 ;

                         PAIR 6 ;

                         DUP 5 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CAR ;

                         SWAP ;

                         SOME ;

                         SWAP ;

                         UPDATE ;

                         DUP 4 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         CAR ;

                         PAIR ;

                         DIG 3 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         DUP ;

                         CDR ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CDR ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CDR ;

                         PUSH nat 1 ;

                         DUP 5 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CAR ;

                         ADD ;

                         PAIR ;

                         PAIR ;

                         DIG 2 ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         DUP 4 ;

                         GET 3 ;

                         DIG 3 ;

                         GET 7 ;

                         ADD ;

                         UPDATE 7 ;

                         DUP ;

                         DUP 4 ;

                         GET 3 ;

                         DIG 2 ;

                         GET 3 ;

                         ADD ;

                         UPDATE 3 ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         DUP 4 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 5 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 5 ;

                         DUP 8 ;

                         CAR ;

                         SWAP ;

                         SOME ;

                         SWAP ;

                         UPDATE ;

                         DIG 5 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         GET 5 ;

                         IF

                           { DIG 3 ;

                             DROP ;

                             DIG 3 ;

                             DUP 3 ;

                             CAR ;

                             PAIR ;

                             NIL (pair address nat) ;

                             DIG 3 ;

                             GET 3 ;

                             SELF_ADDRESS ;

                             PAIR ;

                             CONS ;

                             SENDER ;

                             PAIR ;

                             PAIR ;

                             DIG 2 ;

                             SWAP ;

                             EXEC }

                           { DIG 2 ;

                             DROP ;

                             DIG 3 ;

                             DUP 3 ;

                             CAR ;

                             PAIR ;

                             NIL (pair address nat) ;

                             DIG 3 ;

                             GET 3 ;

                             SELF_ADDRESS ;

                             PAIR ;

                             CONS ;

                             SENDER ;

                             PAIR ;

                             PAIR ;

                             DIG 2 ;

                             SWAP ;

                             EXEC } ;

                         PAIR }

                       { PUSH string "Unknown source" ;

                         SENDER ;

                         DUP 4 ;

                         CAR ;

                         CDR ;

                         CDR ;

                         CAR ;

                         COMPARE ;

                         EQ ;

                         IF { DROP } { FAILWITH } ;

                         PUSH string "No games pending" ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CAR ;

                         DUP 4 ;

                         CDR ;

                         CDR ;

                         CAR ;

                         COMPARE ;

                         LT ;

                         PUSH nat 0 ;

                         DUP 5 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CDR ;

                         COMPARE ;

                         EQ ;

                         OR ;

                         IF { DROP } { FAILWITH } ;

                         DIG 4 ;

                         DIG 2 ;

                         PUSH nat 0 ;

                         PAIR ;

                         PAIR ;

                         LEFT (pair

                                (pair nat

                                      (pair

                                        (pair

                                          (pair

                                            (pair address

                                                  (map (pair address nat)

                                                       (pair nat nat bool nat nat

                                                             address)))

                                            (pair nat

                                                  (big_map nat

                                                           (pair nat (pair address nat)

                                                                 bool

                                                                 address

                                                                 nat

                                                                 timestamp))))

                                          (pair (pair nat nat) (pair address bool)))

                                        (pair

                                          (pair (option address) (big_map address nat))

                                          (pair nat nat))))

                                (list operation)) ;

                         LOOP_LEFT { DUP ;

                                     CAR ;

                                     CDR ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     CDR ;

                                     DUP 3 ;

                                     CAR ;

                                     CAR ;

                                     PUSH nat 10 ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     COMPARE ;

                                     LT ;

                                     DUP 4 ;

                                     CAR ;

                                     CDR ;

                                     CAR ;

                                     CDR ;

                                     DUP 5 ;

                                     CDR ;

                                     CDR ;

                                     CAR ;

                                     COMPARE ;

                                     LT ;

                                     AND ;

                                     IF

                                       { DIG 3 ;

                                         DROP ;

                                         DUP 3 ;

                                         CAR ;

                                         CAR ;

                                         CDR ;

                                         CDR ;

                                         DUP 4 ;

                                         CDR ;

                                         CDR ;

                                         CAR ;

                                         GET ;

                                         IF_NONE { PUSH int 1 ; FAILWITH } {} ;

                                         DUP 4 ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         GET 3 ;

                                         PUSH string "Unknown asset requested" ;

                                         DIG 2 ;

                                         CAR ;

                                         CAR ;

                                         CAR ;

                                         CDR ;

                                         DIG 2 ;

                                         GET ;

                                         IF_NONE { FAILWITH } { SWAP ; DROP } ;

                                         PUSH nat 1000 ;

                                         DUP 3 ;

                                         CAR ;

                                         EDIV ;

                                         IF_NONE

                                           { PUSH string "DIV by 0" ; FAILWITH }

                                           {} ;

                                         CAR ;

                                         PUSH nat 0 ;

                                         DUP 5 ;

                                         PUSH nat 1 ;

                                         LSL ;

                                         DUP 9 ;

                                         AND ;

                                         COMPARE ;

                                         GT ;

                                         PUSH nat 1 ;

                                         DIG 5 ;

                                         ADD ;

                                         NIL (pair address nat) ;

                                         DUP 6 ;

                                         DUP 6 ;

                                         DUP 3 ;

                                         PAIR ;

                                         PAIR ;

                                         DUP 7 ;

                                         GET 5 ;

                                         DIG 4 ;

                                         COMPARE ;

                                         EQ ;

                                         IF

                                           { DROP 2 ;

                                             PUSH nat 2 ;

                                             DUP 7 ;

                                             CAR ;

                                             CAR ;

                                             CDR ;

                                             CAR ;

                                             PUSH nat 1000 ;

                                             SUB ;

                                             ABS ;

                                             DIG 3 ;

                                             MUL ;

                                             MUL ;

                                             DUP 3 ;

                                             SWAP ;

                                             DUP ;

                                             DUG 2 ;

                                             DIG 4 ;

                                             GET 3 ;

                                             SUB ;

                                             ABS ;

                                             UPDATE 3 ;

                                             DUP 4 ;

                                             PUSH nat 2 ;

                                             UPDATE 9 ;

                                             SWAP ;

                                             NIL (pair address nat) ;

                                             DIG 3 ;

                                             DIG 5 ;

                                             GET 7 ;

                                             PAIR ;

                                             CONS ;

                                             PAIR ;

                                             PAIR }

                                           { DIG 3 ;

                                             DUP 8 ;

                                             CAR ;

                                             CAR ;

                                             CDR ;

                                             CAR ;

                                             MUL ;

                                             SWAP ;

                                             DUP ;

                                             DUG 2 ;

                                             CDR ;

                                             DIG 2 ;

                                             CAR ;

                                             CDR ;

                                             DIG 3 ;

                                             DUP 4 ;

                                             DUP 7 ;

                                             GET 10 ;

                                             PAIR ;

                                             CONS ;

                                             PAIR ;

                                             PAIR ;

                                             DUP 4 ;

                                             DUP 3 ;

                                             DIG 5 ;

                                             GET 9 ;

                                             ADD ;

                                             UPDATE 9 ;

                                             DUP ;

                                             DIG 3 ;

                                             DUP 3 ;

                                             GET 3 ;

                                             SUB ;

                                             ABS ;

                                             UPDATE 3 ;

                                             DIG 4 ;

                                             PUSH nat 1 ;

                                             UPDATE 9 ;

                                             DUP 4 ;

                                             CDR ;

                                             DIG 3 ;

                                             DIG 4 ;

                                             CAR ;

                                             CAR ;

                                             PAIR ;

                                             PAIR ;

                                             DUP ;

                                             CDR ;

                                             DIG 3 ;

                                             DIG 2 ;

                                             CAR ;

                                             CAR ;

                                             PAIR ;

                                             PAIR ;

                                             CAR ;

                                             PAIR } ;

                                         DUP ;

                                         CAR ;

                                         CAR ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         CDR ;

                                         DIG 2 ;

                                         CAR ;

                                         CDR ;

                                         DUP 6 ;

                                         CDR ;

                                         DUP 7 ;

                                         CAR ;

                                         CDR ;

                                         DUP 8 ;

                                         CAR ;

                                         CAR ;

                                         CDR ;

                                         CDR ;

                                         DUP 5 ;

                                         DUP 10 ;

                                         CDR ;

                                         CDR ;

                                         CAR ;

                                         SWAP ;

                                         SOME ;

                                         SWAP ;

                                         UPDATE ;

                                         DUP 9 ;

                                         CAR ;

                                         CAR ;

                                         CDR ;

                                         CAR ;

                                         PAIR ;

                                         DIG 8 ;

                                         CAR ;

                                         CAR ;

                                         CAR ;

                                         PAIR ;

                                         PAIR ;

                                         PAIR ;

                                         DUP ;

                                         CDR ;

                                         CDR ;

                                         CDR ;

                                         PUSH nat 1 ;

                                         DUP 3 ;

                                         CDR ;

                                         CDR ;

                                         CAR ;

                                         ADD ;

                                         PAIR ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         CDR ;

                                         CAR ;

                                         PAIR ;

                                         SWAP ;

                                         CAR ;

                                         PAIR ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         GET 5 ;

                                         IF

                                           { DIG 5 ;

                                             DUP 4 ;

                                             GET 3 ;

                                             PAIR ;

                                             DIG 4 ;

                                             SELF_ADDRESS ;

                                             PAIR ;

                                             PAIR ;

                                             DUP 7 ;

                                             SWAP ;

                                             EXEC }

                                           { DIG 5 ;

                                             DUP 4 ;

                                             GET 3 ;

                                             PAIR ;

                                             DIG 4 ;

                                             SELF_ADDRESS ;

                                             PAIR ;

                                             PAIR ;

                                             DUP 8 ;

                                             SWAP ;

                                             EXEC } ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         CDR ;

                                         DUP 3 ;

                                         CAR ;

                                         CDR ;

                                         DUP 4 ;

                                         CAR ;

                                         CAR ;

                                         CDR ;

                                         DUP 5 ;

                                         CAR ;

                                         CAR ;

                                         CAR ;

                                         CDR ;

                                         DIG 6 ;

                                         DIG 7 ;

                                         GET 3 ;

                                         SWAP ;

                                         SOME ;

                                         SWAP ;

                                         UPDATE ;

                                         DIG 5 ;

                                         CAR ;

                                         CAR ;

                                         CAR ;

                                         CAR ;

                                         PAIR ;

                                         PAIR ;

                                         PAIR ;

                                         PAIR ;

                                         DIG 2 ;

                                         PAIR ;

                                         PAIR ;

                                         LEFT (pair

                                                (pair nat

                                                      (pair

                                                        (pair

                                                          (pair

                                                            (pair address

                                                                  (map

                                                                    (pair address nat)

                                                                    (pair nat nat bool

                                                                          nat

                                                                          nat

                                                                          address)))

                                                            (pair nat

                                                                  (big_map nat

                                                                           (pair nat

                                                                                 (pair

                                                                                   address

                                                                                   nat)

                                                                                 bool

                                                                                 address

                                                                                 nat

                                                                                 timestamp))))

                                                          (pair (pair nat nat)

                                                                (pair address bool)))

                                                        (pair

                                                          (pair (option address)

                                                                (big_map address nat))

                                                          (pair nat nat))))

                                                (list operation)) }

                                       { DROP 3 ;

                                         RIGHT (pair

                                                 (pair nat

                                                       (pair

                                                         (pair

                                                           (pair

                                                             (pair address

                                                                   (map

                                                                     (pair address nat)

                                                                     (pair nat nat bool

                                                                           nat

                                                                           nat

                                                                           address)))

                                                             (pair nat

                                                                   (big_map nat

                                                                            (pair nat

                                                                                  (pair

                                                                                    address

                                                                                    nat)

                                                                                  bool

                                                                                  address

                                                                                  nat

                                                                                  timestamp))))

                                                           (pair (pair nat nat)

                                                                 (pair address bool)))

                                                         (pair

                                                           (pair (option address)

                                                                 (big_map address nat))

                                                           (pair nat nat))))

                                                 (list operation)) } } ;

                         SWAP ;

                         DIG 2 ;

                         DIG 3 ;

                         DROP 3 ;

                         DUP ;

                         CAR ;

                         CDR ;

                         DUP ;

                         CDR ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CDR ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CAR ;

                         DUP 4 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         DIG 2 ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         CDR ;

                         PAIR } } }

               { DIG 2 ;