{ parameter (or

              (or

                (or (or (unit %pause) (unit %unpause))

                    (or (address %setAdminCandidate) (unit %acceptAdminCandidate)))

                (or

                  (or (pair %grantRole (string %irole) (list %iaddrs address))

                      (pair %revokeRole (string %irole) (list %iaddrs address)))

                  (or

                    (pair %registerArchetype (nat %id)

                                             (pair (address %mintingValidator)

                                                   (nat %imaxBalanceAllowed)))

                    (pair %applyTokenTransfer (option %from address)

                                              (pair (address %to)

                                                    (pair (nat %tokenId)

                                                          (address %sender)))))))

              (or

                (or

                  (or

                    (pair %mint (address %account)

                                (pair (nat %iarchetypeId) (nat %iserialNumber)))

                    (bytes %setMetadataUri))

                  (or (option %setWhitelist address) (address %setQuartz)))

                (or (or (address %setArchLedger) (address %setArchOwner))

                    (pair %updateMaxBalanceAllowed (nat %archid) (option %v nat))))) ;

  storage (pair (address %admin)

                (pair (option %whitelist address)

                      (pair (address %quartz)

                            (pair (address %archetype_ledger)

                                  (pair (address %archetype_balance)

                                        (pair (bool %paused)

                                              (pair (option %adminCandidate address)

                                                    (pair

                                                      (map %role string (set address))

                                                      (big_map %metadata string bytes))))))))) ;

  code { LAMBDA

           (pair string bool)

           bool

           { UNPAIR 2 ;

             PUSH unit Unit ;

             DUP 3 ;

             NOT ;

             IF

               { PUSH bool True ; SWAP ; DROP }

               { PUSH string "CONTRACT_PAUSED" ; FAILWITH } ;

             DUG 2 ;

             DROP 2 } ;

         LAMBDA

           (pair (map string (set address)) (pair string address))

           bool

           { UNPAIR 3 ;

             PUSH unit Unit ;

             DUP 2 ;

             DUP 4 ;

             GET ;

             IF_NONE

               { PUSH string "role" ; PUSH string "AssetNotFound" ; PAIR ; FAILWITH }

               {} ;

             DUP 5 ;

             MEM ;

             SWAP ;

             DROP ;

             DUG 3 ;

             DROP 3 } ;

         LAMBDA

           (pair string

                 (pair (map string (set address))

                       (pair string

                             (lambda

                               (pair (map string (set address)) (pair string address))

                               bool))))

           bool

           { UNPAIR 4 ;

             PUSH unit Unit ;

             DUP 5 ;

             SENDER ;

             PUSH string "minter" ;

             PAIR ;

             DUP 5 ;

             PAIR ;

             EXEC ;

             IF

               { PUSH bool True ; SWAP ; DROP }

               { PUSH string "CALLER_NOT_MINTER" ; FAILWITH } ;

             DUG 4 ;

             DROP 4 } ;

         LAMBDA

           (pair nat (pair nat nat))

           nat

           { UNPAIR 3 ; PUSH unit Unit ; DUP 4 ; PUSH nat 100000 ; DUP 5 ; MUL ; ADD ; SWAP ; DROP ; DUG 3 ; DROP 3 } ;

         NIL operation ;

         DIG 5 ;

         UNPAIR ;

         DIP { UNPAIR 9 } ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { DROP ;

                         DUP ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 6 ;

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

                         PUSH bool True ;

                         DIP { DIG 5 ; DROP } ;

                         DUG 5 ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR }

                       { DROP ;

                         DUP ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 6 ;

                         NOT ;

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

                         PUSH bool False ;

                         DIP { DIG 5 ; DROP } ;

                         DUG 5 ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 15 ;

                         DUP 8 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r0" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         SOME ;

                         DIP { DIG 7 ; DROP } ;

                         DUG 7 ;

                         DROP ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR }

                       { DROP ;

                         DUP 14 ;

                         DUP 7 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r1" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 7 ;

                         IF_NONE

                           { PUSH string "ADMIN_CANDIDATE_NOT_SET" ; FAILWITH }

                           { DUP ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

                             IF

                               { PUSH string "CALLER_NOT_ADMIN_CANDIDATE" ; FAILWITH }

                               {} ;

                             DUP ;

                             DIP { DIG 1 ; DROP } ;

                             DUG 1 ;

                             NONE address ;

                             DIP { DIG 7 ; DROP } ;

                             DUG 7 ;

                             DROP } ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR } } }

               { IF_LEFT

                   { IF_LEFT

                       { UNPAIR ;

                         SWAP ;

                         DUP 3 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 16 ;

                         DUP 9 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r2" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         ITER { DUP 11 ;

                                DUP 12 ;

                                DUP 5 ;

                                GET ;

                                IF_NONE

                                  { PUSH string "role" ;

                                    PUSH string "AssetNotFound" ;

                                    PAIR ;

                                    FAILWITH }

                                  {} ;

                                PUSH bool True ;

                                DUP 4 ;

                                UPDATE ;

                                SOME ;

                                DUP 5 ;

                                UPDATE ;

                                DIP { DIG 10 ; DROP } ;

                                DUG 10 ;

                                DROP } ;

                         DROP 2 ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR }

                       { UNPAIR ;

                         SWAP ;

                         DUP 3 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 16 ;

                         DUP 9 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r3" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         ITER { DUP 11 ;

                                DUP 12 ;

                                DUP 5 ;

                                GET ;

                                IF_NONE

                                  { PUSH string "role" ;

                                    PUSH string "AssetNotFound" ;

                                    PAIR ;

                                    FAILWITH }

                                  {} ;

                                PUSH bool False ;

                                DUP 4 ;

                                UPDATE ;

                                SOME ;

                                DUP 5 ;

                                UPDATE ;

                                DIP { DIG 10 ; DROP } ;

                                DUG 10 ;

                                DROP } ;

                         DROP 2 ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         DUP 15 ;

                         DUP 17 ;

                         PUSH string "minter" ;

                         PAIR ;

                         DUP 13 ;

                         PAIR ;

                         PUSH string "CALLER_NOT_MINTER" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r5" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 17 ;

                         DUP 10 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r6" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 13 ;

                         DUP 8 ;

                         CONTRACT %add (pair nat (pair address (option nat))) ;

                         IF_NONE

                           { PUSH string "add" ; PUSH string "EntryNotFound" ; PAIR ; FAILWITH }

                           {} ;

                         PUSH mutez 0 ;

                         DUP 4 ;

                         SOME ;

                         DUP 6 ;

                         PAIR ;

                         DUP 7 ;

                         PAIR ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 12 ; DROP } ;

                         DUG 12 ;

                         DROP 3 ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR }

                       { UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         DUP 7 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         SELF_ADDRESS ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         OR ;

                         NOT ;

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

                         DUP 18 ;

                         DUP 11 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r7" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 4 ;

                         IF_NONE { SELF_ADDRESS } {} ;

                         SELF_ADDRESS ;

                         DUP 3 ;

                         DUP 6 ;

                         PAIR ;

                         DUP 3 ;

                         PAIR ;

                         DUP 5 ;

                         PAIR ;

                         VIEW "validateTransfer" string ;

                         IF_NONE

                           { PUSH string "INTERNAL_ERROR" ; FAILWITH }

                           { PUSH string "" ;

                             DUP 2 ;

                             COMPARE ;

                             NEQ ;

                             IF { DUP ; FAILWITH } {} ;

                             DROP } ;

                         SELF_ADDRESS ;

                         DUP 4 ;

                         VIEW "getArchetypeId" (option nat) ;

                         IF_NONE { PUSH string "INTERNAL_ERROR" ; FAILWITH } {} ;

                         IF_NONE

                           { PUSH string "GET_ARCHETYPE_ID_FAILED" ; FAILWITH }

                           {} ;

                         DUP 16 ;

                         DUP 12 ;

                         CONTRACT %updateBalance (pair address (pair nat (or nat nat))) ;

                         IF_NONE

                           { PUSH string "updateBalance" ;

                             PUSH string "EntryNotFound" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         PUSH mutez 0 ;

                         PUSH nat 1 ;

                         LEFT nat ;

                         DUP 5 ;

                         PAIR ;

                         DUP 9 ;

                         PAIR ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 15 ; DROP } ;

                         DUG 15 ;

                         DUP 6 ;

                         IF_NONE

                           {}

                           { DUP 17 ;

                             DUP 13 ;

                             CONTRACT %updateBalance (pair address

                                                           (pair nat (or nat nat))) ;

                             IF_NONE

                               { PUSH string "updateBalance" ;

                                 PUSH string "EntryNotFound" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             PUSH mutez 0 ;

                             PUSH nat 1 ;

                             RIGHT nat ;

                             DUP 6 ;

                             PAIR ;

                             DUP 5 ;

                             PAIR ;

                             TRANSFER_TOKENS ;

                             CONS ;

                             DIP { DIG 16 ; DROP } ;

                             DUG 16 ;

                             DROP } ;

                         DROP 6 ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR } } } }

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         DUP 15 ;

                         DUP 17 ;

                         PUSH string "minter" ;

                         PAIR ;

                         DUP 13 ;

                         PAIR ;

                         PUSH string "CALLER_NOT_MINTER" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r8" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 17 ;

                         DUP 10 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r9" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 7 ;

                         DUP 3 ;

                         VIEW "containsArchId" bool ;

                         IF_NONE

                           { PUSH string "ARCHLEDGER_NOT_SET" ; FAILWITH }

                           { DUP ;

                             NOT ;

                             IF

                               { PUSH string "ARCHETYPE_NOT_REGISTERED" ; FAILWITH }

                               {} ;

                             DROP } ;

                         DUP 7 ;

                         DUP 3 ;

                         VIEW "getValidator" address ;

                         IF_NONE

                           { PUSH string "ARCHLEDGER_NOT_SET" ; FAILWITH }

                           { DUP 14 ;

                             DUP 2 ;

                             CONTRACT %validateMint (pair nat nat) ;

                             IF_NONE

                               { PUSH string "validateMint" ;

                                 PUSH string "EntryNotFound" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             PUSH mutez 0 ;

                             DUP 5 ;

                             DUP 7 ;

                             PAIR ;

                             TRANSFER_TOKENS ;

                             CONS ;

                             DIP { DIG 13 ; DROP } ;

                             DUG 13 ;

                             DROP } ;

                         DUP 14 ;

                         DUP 2 ;

                         DUP 4 ;

                         PAIR ;

                         PUSH nat 100000 ;

                         PAIR ;

                         EXEC ;

                         DUP 14 ;

                         SELF_ADDRESS ;

                         CONTRACT %applyTokenTransfer (pair (option address)

                                                            (pair address

                                                                  (pair nat address))) ;

                         IF_NONE

                           { PUSH string "applyTokenTransfer" ;

                             PUSH string "EntryNotFound" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         PUSH mutez 0 ;

                         SENDER ;

                         DUP 5 ;

                         PAIR ;

                         DUP 8 ;

                         PAIR ;

                         NONE address ;

                         PAIR ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 13 ; DROP } ;

                         DUG 13 ;

                         DUP 14 ;

                         DUP 8 ;

                         CONTRACT %mint (pair address nat) ;

                         IF_NONE

                           { PUSH string "mint" ;

                             PUSH string "EntryNotFound" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         PUSH mutez 0 ;

                         DUP 4 ;

                         DUP 8 ;

                         PAIR ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 13 ; DROP } ;

                         DUG 13 ;

                         DROP 4 ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 15 ;

                         DUP 8 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r4" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DIG 9 ;

                         DUP 2 ;

                         SOME ;

                         PUSH string "" ;

                         UPDATE ;

                         DUG 9 ;

                         DROP ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 15 ;

                         DUP 8 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r10" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         DIP { DIG 2 ; DROP } ;

                         DUG 2 ;

                         DROP ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 15 ;

                         DUP 8 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r11" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         DIP { DIG 3 ; DROP } ;

                         DUG 3 ;

                         DROP ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR } } }

               { IF_LEFT

                   { IF_LEFT

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 15 ;

                         DUP 8 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r12" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         DIP { DIG 4 ; DROP } ;

                         DUG 4 ;

                         DROP ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 15 ;

                         DUP 8 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r13" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         DIP { DIG 5 ; DROP } ;

                         DUG 5 ;

                         DROP ;

                         PAIR 9 ;

                         DIG 1 ;

                         PAIR } }

                   { UNPAIR ;

                     SWAP ;

                     DUP 3 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     DUP 6 ;

                     DUP 3 ;

                     VIEW "getMaxBalance" (option nat) ;

                     IF_NONE { PUSH string "INTERNAL_ERROR" ; FAILWITH } {} ;

                     DUP ;

                     IF_NONE

                       { PUSH string "CANNOT_UPDATE_NONE_VALUE" ; FAILWITH }

                       { DUP 3 ;

                         IF_NONE

                           {}

                           { DUP 2 ;

                             DUP 2 ;

                             COMPARE ;

                             GT ;

                             NOT ;

                             IF

                               { PUSH string "CANNOT_DECREASE_MAX_BALANCE" ; FAILWITH }

                               {} ;

                             DROP } ;

                         DUP 14 ;

                         DUP 9 ;

                         CONTRACT %setMaxBalanceAllowed (pair nat (option nat)) ;

                         IF_NONE

                           { PUSH string "setMaxBalanceAllowed" ;

                             PUSH string "EntryNotFound" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         PUSH mutez 0 ;

                         DUP 6 ;

                         DUP 8 ;

                         PAIR ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 13 ; DROP } ;

                         DUG 13 ;

                         DROP } ;

                     DROP 3 ;

                     PAIR 9 ;

                     DIG 1 ;

                     PAIR } } } ;

         DIP { DROP 4 } } ;

  view "getArchetypeId" nat (option nat)

        { CAR ;

          UNIT ;

          NONE nat ;

          PUSH nat 100000 ;

          DUP 4 ;

          EDIV ;

          IF_NONE {} { DUP ; CAR ; SOME ; DIP { DIG 1 ; DROP } ; DUG 1 ; DROP } ;

          DUP ;

          DIP { DIG 1 ; DROP } ;

          DUG 1 ;

          DROP ;

          DIP { DROP } } ;

  view "validateTransfer" (pair nat (pair address (pair address address))) string

        { UNPAIR ;

          DIP { CDR ; UNPAIR ; SWAP ; CDR ; CDR ; CDR ; CDR ; CDR ; UNPAIR ; SWAP ; DROP } ;

          UNPAIR 4 ;

          UNIT ;

          PUSH string "" ;

          DUP 7 ;

          PUSH string "minter" ;

          GET ;

          IF_NONE

            { PUSH string "role" ; PUSH string "AssetNotFound" ; PAIR ; FAILWITH }

            {} ;

          DUP 6 ;

          MEM ;

          NOT ;

          IF

            { DUP 8 ;

              IF_NONE

                {}

                { DUP ;

                  DUP 7 ;

                  DUP 7 ;

                  PAIR ;

                  DUP 9 ;

                  PAIR ;

                  VIEW "assertTransfer" string ;

                  IF_NONE

                    { PUSH string "WHITELIST_ERROR" ; DIP { DIG 1 ; DROP } ; DUG 1 }

                    { DUP ; DIP { DIG 2 ; DROP } ; DUG 2 ; DROP } ;

                  DROP } }

            {} ;

          PUSH string "" ;

          DUP 2 ;

          COMPARE ;

          EQ ;

          IF

            { SELF_ADDRESS ;

              DUP 6 ;

              DUP 5 ;

              PAIR ;

              VIEW "validateBalance" string ;

              IF_NONE

                { PUSH string "INTERNAL_ERROR" ; SWAP ; DROP }

                { DUP ; DIP { DIG 1 ; DROP } ; DUG 1 ; DROP } }

            {} ;

          DUP ;

          DIP { DIG 1 ; DROP } ;