{ parameter (or

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

                  (or (unit %default)

                      (pair %start (mutez %roscaTotal)

                                   (pair (int %roscaDuration) (nat %maxParticipants)))))

              (or

                (or (or (unit %join) (unit %start_contributing))

                    (or (unit %contribute) (unit %end_contributing)))

                (or (or (unit %disturbute) (unit %continue))

                    (or (unit %reset) (address %changeAdmin))))) ;

  storage (pair (address %owner) (mutez %totalRosca) (int %durationRosca)

                (nat %maxUsers)

                (int %_state)

                (map %participant address

                                  (pair (nat %id) (bool %contributed)

                                        (bool %pot_received)))

                (mutez %rosca_total)

                (int %contributing_duration)

                (nat %max_participants)

                (bool %paused)

                (mutez %pot)

                (nat %participants_count)

                (nat %contributors_count)

                (mutez %contribute_amount)

                (option %end_time timestamp)

                (option %receiver address)

                (address %admin)) ;

  code { LAMBDA

           bool

           bool

           { PUSH unit Unit ;

             DUP 2 ;

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

             PUSH bool True ;

             SWAP ;

             DROP 1 ;

             SWAP ;

             DROP 1 } ;

         LAMBDA

           (pair (map address (pair (nat %id) (bool %contributed) (bool %pot_received)))

                 address)

           bool

           { UNPAIR ;

             PUSH unit Unit ;

             DUP 2 ;

             DUP 4 ;

             GET ;

             IF_NONE

               { PUSH string "participant" ; PUSH string "ASSET_NOT_FOUND" ; PAIR ; FAILWITH }

               {} ;

             CDR ;

             CAR ;

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

             PUSH bool True ;

             SWAP ;

             DROP 1 ;

             DUG 2 ;

             DROP 2 } ;

         LAMBDA

           (map address (pair (nat %id) (bool %contributed) (bool %pot_received)))

           bool

           { PUSH unit Unit ;

             DUP 2 ;

             ITER { UNPAIR ;

                    DUP 4 ;

                    DUP 2 ;

                    GET ;

                    IF_NONE

                      { PUSH string "participant" ;

                        PUSH string "ASSET_NOT_FOUND" ;

                        PAIR ;

                        FAILWITH }

                      {} ;

                    CDR ;

                    CAR ;

                    NOT ;

                    IF { PUSH string "NOT ALL CONTRIBUTED" ; FAILWITH } {} ;

                    DROP 2 } ;

             PUSH bool True ;

             SWAP ;

             DROP 1 ;

             SWAP ;

             DROP 1 } ;

         LAMBDA

           (map address (pair (nat %id) (bool %contributed) (bool %pot_received)))

           bool

           { PUSH unit Unit ;

             DUP 2 ;

             ITER { UNPAIR ;

                    DUP 4 ;

                    DUP 2 ;

                    GET ;

                    IF_NONE

                      { PUSH string "participant" ;

                        PUSH string "ASSET_NOT_FOUND" ;

                        PAIR ;

                        FAILWITH }

                      {} ;

                    CDR ;

                    CDR ;

                    NOT ;

                    IF { PUSH string "NOT ALL RECEIVED" ; FAILWITH } {} ;

                    DROP 2 } ;

             PUSH bool True ;

             SWAP ;

             DROP 1 ;

             SWAP ;

             DROP 1 } ;

         LAMBDA

           (pair mutez nat)

           mutez

           { UNPAIR ;

             PUSH unit Unit ;

             PUSH nat 0 ;

             DUP 4 ;

             COMPARE ;

             GT ;

             NOT ;

             IF { PUSH string "ANY PARTICIPANTS DOESNT EXIST" ; FAILWITH } {} ;

             PUSH mutez 1 ;

             PUSH nat 1 ;

             DUP 5 ;

             INT ;

             PAIR ;

             PUSH nat 1 ;

             DUP 5 ;

             PUSH mutez 1 ;

             SWAP ;

             EDIV ;

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

             CAR ;

             INT ;

             PAIR ;

             DIP 1 { UNPAIR } ;

             UNPAIR ;

             DIG 3 ;

             DUP ;

             DIG 3 ;

             DUP ;

             DUG 4 ;

             MUL ;

             PUSH nat 0 ;

             COMPARE ;

             EQ ;

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

             PUSH int 0 ;

             DIG 4 ;

             DUP ;

             DUG 5 ;

             COMPARE ;

             GE ;

             IF { INT } { NEG } ;

             MUL ;

             DIP 1 { MUL ; ABS } ;

             DIP 2

                  { PUSH mutez 1 ;

                    SWAP ;

                    EDIV ;

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

                    CAR } ;

             ABS ;

             DIG 2 ;

             MUL ;

             EDIV ;

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

             CAR ;

             PUSH mutez 1 ;

             MUL ;

             SWAP ;

             DROP 1 ;

             DUG 2 ;

             DROP 2 } ;

         NIL operation ;

         DIG 6 ;

         UNPAIR ;

         DIP 1 { UNPAIR 17 } ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { DROP 1 ;

                     DUP 23 ;

                     DUP 11 ;

                     EXEC ;

                     NOT ;

                     IF { PUSH string "ALREADY PAUSED" ; FAILWITH } {} ;

                     PUSH bool True ;

                     DIP 1 { DIG 9 ; DROP 1 } ;

                     DUG 9 ;

                     NIL operation ;

                     NIL operation ;

                     DUP 20 ;

                     ITER { CONS } ;

                     NOW ;

                     EMIT %Paused timestamp ;

                     CONS ;

                     ITER { CONS } ;

                     DIP 1 { DIG 17 ; DROP 1 } ;

                     DUG 17 ;

                     PAIR 17 ;

                     SWAP ;

                     PAIR }

                   { DROP 1 ;

                     DUP 10 ;

                     NOT ;

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

                     PUSH bool False ;

                     DIP 1 { DIG 9 ; DROP 1 } ;

                     DUG 9 ;

                     NIL operation ;

                     NIL operation ;

                     DUP 20 ;

                     ITER { CONS } ;

                     NOW ;

                     EMIT %Resumed timestamp ;

                     CONS ;

                     ITER { CONS } ;

                     DIP 1 { DIG 17 ; DROP 1 } ;

                     DUG 17 ;

                     PAIR 17 ;

                     SWAP ;

                     PAIR } }

               { IF_LEFT

                   { DROP 1 ; PAIR 17 ; SWAP ; PAIR }

                   { UNPAIR ;

                     SWAP ;

                     UNPAIR ;

                     SWAP ;

                     DUP 20 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     DUP 8 ;

                     PUSH int 0 ;

                     COMPARE ;

                     NEQ ;

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

                     DUP 26 ;

                     DUP 14 ;

                     EXEC ;

                     NOT ;

                     IF { PUSH string "Rosca is Paused" ; FAILWITH } {} ;

                     DUP 8 ;

                     DUP ;

                     PUSH int 0 ;

                     COMPARE ;

                     EQ ;

                     IF

                       { DUP 4 ;

                         DIP 1 { DIG 10 ; DROP 1 } ;

                         DUG 10 ;

                         DUP 3 ;

                         DIP 1 { DIG 11 ; DROP 1 } ;

                         DUG 11 ;

                         DUP 2 ;

                         DIP 1 { DIG 12 ; DROP 1 } ;

                         DUG 12 ;

                         PUSH int 1 ;

                         DIP 1 { DIG 8 ; DROP 1 } ;

                         DUG 8 }

                       { PUSH string "INVALID_STATE" ; FAILWITH } ;

                     DROP 4 ;

                     PAIR 17 ;

                     SWAP ;

                     PAIR } } }

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { DROP 1 ;

                         DUP 5 ;

                         PUSH int 1 ;

                         COMPARE ;

                         NEQ ;

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

                         DUP 23 ;

                         DUP 11 ;

                         EXEC ;

                         NOT ;

                         IF { PUSH string "Rosca is Paused" ; FAILWITH } {} ;

                         DUP 9 ;

                         DUP 13 ;

                         COMPARE ;

                         LE ;

                         NOT ;

                         IF

                           { PUSH string "Maximum number of participants reached." ;

                             FAILWITH }

                           {} ;

                         DUP 6 ;

                         SENDER ;

                         MEM ;

                         IF

                           { PUSH string "c1" ;

                             PUSH string "INVALID_CONDITION" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         PUSH nat 1 ;

                         DUP 13 ;

                         ADD ;

                         DIP 1 { DIG 11 ; DROP 1 } ;

                         DUG 11 ;

                         DUP 6 ;

                         SENDER ;

                         MEM ;

                         IF

                           { PUSH string "participant" ;

                             PUSH string "KEY_EXISTS" ;

                             PAIR ;

                             FAILWITH }

                           { DUP 6 ;

                             PUSH bool False ;

                             PUSH bool False ;

                             PAIR ;

                             DUP 14 ;

                             PAIR ;

                             SOME ;

                             SENDER ;

                             UPDATE ;

                             DIP 1 { DIG 5 ; DROP 1 } ;

                             DUG 5 } ;

                         NIL operation ;

                         NIL operation ;

                         DUP 20 ;

                         ITER { CONS } ;

                         NOW ;

                         SENDER ;

                         PAIR ;

                         EMIT %Joined (pair (address %user) (timestamp %timestamp)) ;

                         CONS ;

                         ITER { CONS } ;

                         DIP 1 { DIG 17 ; DROP 1 } ;

                         DUG 17 ;

                         PAIR 17 ;

                         SWAP ;

                         PAIR }

                       { DROP 1 ;

                         DUP 17 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 5 ;

                         PUSH int 1 ;

                         COMPARE ;

                         NEQ ;

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

                         DUP 23 ;

                         DUP 11 ;

                         EXEC ;

                         NOT ;

                         IF { PUSH string "Rosca is Paused" ; FAILWITH } {} ;

                         DUP 5 ;

                         DUP ;

                         PUSH int 1 ;

                         COMPARE ;

                         EQ ;

                         IF

                           { DUP 9 ;

                             NOW ;

                             ADD ;

                             SOME ;

                             DIP 1 { DIG 15 ; DROP 1 } ;

                             DUG 15 ;

                             NIL operation ;

                             NIL operation ;

                             DUP 21 ;

                             ITER { CONS } ;

                             NOW ;

                             EMIT %ContributionStarted timestamp ;

                             CONS ;

                             ITER { CONS } ;

                             DIP 1 { DIG 18 ; DROP 1 } ;

                             DUG 18 ;

                             PUSH int 2 ;

                             DIP 1 { DIG 5 ; DROP 1 } ;

                             DUG 5 }

                           { PUSH string "INVALID_STATE" ; FAILWITH } ;

                         DROP 1 ;

                         PAIR 17 ;

                         SWAP ;

                         PAIR } }

                   { IF_LEFT

                       { DROP 1 ;

                         DUP 5 ;

                         PUSH int 2 ;

                         COMPARE ;

                         NEQ ;

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

                         DUP 23 ;

                         DUP 11 ;

                         EXEC ;

                         NOT ;

                         IF { PUSH string "Rosca is Paused" ; FAILWITH } {} ;

                         DUP 6 ;

                         SENDER ;

                         MEM ;

                         NOT ;

                         IF { PUSH string "NOT PARTICIPANT" ; FAILWITH } {} ;

                         DUP 22 ;

                         SENDER ;

                         DUP 8 ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF { PUSH string "Already Contributed" ; FAILWITH } {} ;

                         DUP 19 ;

                         DUP 13 ;

                         DUP 9 ;

                         PAIR ;

                         EXEC ;

                         AMOUNT ;

                         COMPARE ;

                         EQ ;

                         NOT ;

                         IF

                           { PUSH string "PLEASE MAKE SURE TO SEND THE EXACT AMOUNT" ;

                             FAILWITH }

                           {} ;

                         DUP 15 ;

                         IF_NONE

                           { PUSH bool False }

                           { NOW ; DUP 2 ; COMPARE ; GT ; SWAP ; DROP 1 } ;

                         NOT ;

                         IF { PUSH string "Contibution finished" ; FAILWITH } {} ;

                         PUSH nat 1 ;

                         DUP 14 ;

                         ADD ;

                         DIP 1 { DIG 12 ; DROP 1 } ;

                         DUG 12 ;

                         DUP 6 ;

                         DUP 7 ;

                         SENDER ;

                         GET ;

                         IF_NONE

                           { PUSH string "participant" ;

                             PUSH string "ASSET_NOT_FOUND" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         UNPAIR ;

                         SWAP ;

                         CDR ;

                         PUSH bool True ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         SOME ;

                         SENDER ;

                         UPDATE ;

                         DIP 1 { DIG 5 ; DROP 1 } ;

                         DUG 5 ;

                         AMOUNT ;

                         DUP 12 ;

                         ADD ;

                         DIP 1 { DIG 10 ; DROP 1 } ;

                         DUG 10 ;

                         NIL operation ;

                         NIL operation ;

                         DUP 20 ;

                         ITER { CONS } ;

                         NOW ;

                         SENDER ;

                         PAIR ;

                         EMIT %Contributed (pair (address %user) (timestamp %timestamp)) ;

                         CONS ;

                         ITER { CONS } ;

                         DIP 1 { DIG 17 ; DROP 1 } ;

                         DUG 17 ;

                         PAIR 17 ;

                         SWAP ;

                         PAIR }

                       { DROP 1 ;

                         DUP 17 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 5 ;

                         PUSH int 2 ;

                         COMPARE ;

                         NEQ ;

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

                         DUP 23 ;

                         DUP 11 ;

                         EXEC ;

                         NOT ;

                         IF { PUSH string "Rosca is Paused" ; FAILWITH } {} ;

                         DUP 15 ;

                         IF_NONE

                           { PUSH bool False }

                           { DUP ; NOW ; COMPARE ; GT ; SWAP ; DROP 1 } ;

                         NOT ;

                         IF { PUSH string "Contibution finished" ; FAILWITH } {} ;

                         DUP 5 ;

                         DUP ;

                         PUSH int 2 ;

                         COMPARE ;

                         EQ ;

                         IF

                           { DUP 7 ;

                             ITER { UNPAIR ;

                                    DUP 9 ;

                                    DUP 2 ;

                                    GET ;

                                    IF_NONE

                                      { PUSH string "participant" ;

                                        PUSH string "ASSET_NOT_FOUND" ;

                                        PAIR ;

                                        FAILWITH }

                                      {} ;

                                    CDR ;

                                    CAR ;

                                    NOT ;

                                    IF

                                      { DUP 9 ;

                                        NONE (pair nat bool bool) ;

                                        DUP 3 ;

                                        UPDATE ;

                                        DIP 1 { DIG 8 ; DROP 1 } ;

                                        DUG 8 ;

                                        PUSH int 0 ;

                                        PUSH int 1 ;

                                        DUP 17 ;

                                        SUB ;

                                        COMPARE ;

                                        GE ;

                                        IF

                                          { PUSH int 1 ; DUP 16 ; SUB ; ABS }

                                          { PUSH string "NAT_NEG_ASSIGN" ; FAILWITH } ;

                                        DIP 1 { DIG 14 ; DROP 1 } ;

                                        DUG 14 }

                                      {} ;

                                    DROP 2 } ;

                             DUP 7 ;

                             ITER { UNPAIR ;

                                    DUP 9 ;

                                    DUP 2 ;

                                    GET ;

                                    IF_NONE

                                      { PUSH string "participant" ;

                                        PUSH string "ASSET_NOT_FOUND" ;

                                        PAIR ;

                                        FAILWITH }

                                      {} ;

                                    CDR ;

                                    CDR ;

                                    NOT ;

                                    IF

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

                                      {} ;

                                    DROP 2 } ;

                             PUSH int 3 ;

                             DIP 1 { DIG 5 ; DROP 1 } ;

                             DUG 5 }

                           { PUSH string "INVALID_STATE" ; FAILWITH } ;

                         DROP 1 ;

                         PAIR 17 ;

                         SWAP ;

                         PAIR } } }

               { IF_LEFT

                   { IF_LEFT

                       { DROP 1 ;

                         DUP 17 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 5 ;

                         PUSH int 3 ;

                         COMPARE ;

                         NEQ ;

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

                         DUP 23 ;

                         DUP 11 ;

                         EXEC ;

                         NOT ;

                         IF { PUSH string "Rosca is Paused" ; FAILWITH } {} ;

                         PUSH mutez 0 ;

                         DUP 12 ;

                         COMPARE ;

                         GT ;

                         NOT ;

                         IF { PUSH string "Pot is equal to zero" ; FAILWITH } {} ;

                         DUP 5 ;

                         DUP ;

                         PUSH int 3 ;

                         COMPARE ;

                         EQ ;

                         IF

                           { DUP 17 ;

                             IF_NONE { PUSH string "RECEIVER IS NONE" ; FAILWITH } {} ;

                             PUSH mutez 0 ;

                             DIP 1 { DIG 12 ; DROP 1 } ;

                             DUG 12 ;

                             DUP 8 ;

                             DUP 9 ;

                             DUP 3 ;

                             GET ;

                             IF_NONE

                               { PUSH string "participant" ;

                                 PUSH string "ASSET_NOT_FOUND" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             UNPAIR ;

                             SWAP ;

                             UNPAIR ;

                             SWAP ;

                             DROP 1 ;

                             PUSH bool True ;

                             SWAP ;

                             PAIR ;

                             SWAP ;

                             PAIR ;

                             SOME ;

                             DUP 3 ;

                             UPDATE ;

                             DIP 1 { DIG 7 ; DROP 1 } ;

                             DUG 7 ;

                             NIL operation ;

                             NIL operation ;

                             DUP 22 ;

                             ITER { CONS } ;

                             DUP 3 ;

                             CONTRACT unit ;

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

                             BALANCE ;

                             UNIT ;

                             TRANSFER_TOKENS ;

                             CONS ;

                             ITER { CONS } ;

                             DIP 1 { DIG 19 ; DROP 1 } ;

                             DUG 19 ;

                             NONE address ;

                             DIP 1 { DIG 17 ; DROP 1 } ;

                             DUG 17 ;

                             DROP 1 ;

                             PUSH int 4 ;

                             DIP 1 { DIG 5 ; DROP 1 } ;

                             DUG 5 }

                           { PUSH string "INVALID_STATE" ; FAILWITH } ;

                         DROP 1 ;

                         PAIR 17 ;

                         SWAP ;

                         PAIR }

                       { DROP 1 ;

                         DUP 17 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 5 ;

                         PUSH int 4 ;

                         COMPARE ;

                         NEQ ;

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

                         DUP 23 ;

                         DUP 11 ;

                         EXEC ;

                         NOT ;

                         IF { PUSH string "Rosca is Paused" ; FAILWITH } {} ;

                         DUP 20 ;

                         DUP 7 ;

                         EXEC ;

                         IF

                           { PUSH string "c3" ;

                             PUSH string "INVALID_CONDITION" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 5 ;

                         DUP ;

                         PUSH int 4 ;

                         COMPARE ;

                         EQ ;

                         IF

                           { DUP 7 ;

                             ITER { UNPAIR ;

                                    DUP 9 ;

                                    DUP 10 ;

                                    DUP 3 ;

                                    GET ;

                                    IF_NONE

                                      { PUSH string "participant" ;

                                        PUSH string "ASSET_NOT_FOUND" ;

                                        PAIR ;

                                        FAILWITH }

                                      {} ;

                                    UNPAIR ;

                                    SWAP ;

                                    CDR ;

                                    PUSH bool False ;

                                    PAIR ;

                                    SWAP ;

                                    PAIR ;

                                    SOME ;

                                    DUP 3 ;

                                    UPDATE ;

                                    DIP 1 { DIG 8 ; DROP 1 } ;

                                    DUG 8 ;

                                    DROP 2 } ;

                             PUSH nat 0 ;

                             DIP 1 { DIG 13 ; DROP 1 } ;

                             DUG 13 ;

                             PUSH int 2 ;

                             DIP 1 { DIG 5 ; DROP 1 } ;

                             DUG 5 }

                           { PUSH string "INVALID_STATE" ; FAILWITH } ;

                         DROP 1 ;

                         PAIR 17 ;

                         SWAP ;

                         PAIR } }

                   { IF_LEFT

                       { DROP 1 ;

                         DUP 17 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 5 ;

                         PUSH int 4 ;

                         COMPARE ;

                         NEQ ;

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

                         DUP 20 ;

                         DUP 7 ;

                         EXEC ;

                         NOT ;

                         IF { PUSH string "Not All Recevied" ; FAILWITH } {} ;

                         DUP 5 ;

                         DUP ;

                         PUSH int 4 ;

                         COMPARE ;

                         EQ ;

                         IF

                           { DUP 7 ;

                             ITER { UNPAIR ;

                                    DUP 9 ;

                                    NONE (pair nat bool bool) ;

                                    DUP 3 ;

                                    UPDATE ;

                                    DIP 1 { DIG 8 ; DROP 1 } ;

                                    DUG 8 ;

                                    DROP 2 } ;

                             PUSH int 0 ;

                             DIP 1 { DIG 5 ; DROP 1 } ;

                             DUG 5 }

                           { PUSH string "INVALID_STATE" ; FAILWITH } ;

                         DROP 1 ;

                         PAIR 17 ;

                         SWAP ;

                         PAIR }

                       { PUSH address "tz1dtZf7WBC6VsCFof4mtxJfhpfmNeNb7Z1R" ;

                         DUP 2 ;

                         COMPARE ;

                         EQ ;

                         IF

                           { PUSH bool True }

                           { PUSH address "tz1f4mS8qV5D8fVZ8hQAJTUtmEjydsJiJNpu" ;

                             DUP 2 ;

                             COMPARE ;