;
;
;     Model statements for module:  BasicProcess.Create 1 (Household MainShop Shopping Patterns Specific)
;

316$          CREATE,        mainspecific,DaysToBaseTime(0.1),Entity 1:DaysToBaseTime(7):NEXT(317$);

317$          ASSIGN:        Household MainShop Shopping Patterns Specific.NumberOut=
                             Household MainShop Shopping Patterns Specific.NumberOut + 1:NEXT(37$);


;
;
;     Model statements for module:  BasicProcess.Decide 15 (Decide shopping day)
;
37$           BRANCH,        1:
                             With,(33.3)/100,39$,Yes:
                             With,(33.3)/100,40$,Yes:
                             Else,38$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 30 (Thursday)
;
38$           ASSIGN:        shop=5:NEXT(47$);


;
;
;     Model statements for module:  BasicProcess.Assign 34 (Show shopping day)
;
47$           ASSIGN:        mainshopday=shop:NEXT(41$);


;
;
;     Model statements for module:  AdvancedProcess.Hold 9 (Wait for the main shop day)
;
41$           QUEUE,         Wait for the main shop day.Queue;
              SCAN:          CalDayOfWeek(TNOW) == shop:NEXT(43$);


;
;
;     Model statements for module:  BasicProcess.Assign 33 (Change picture)
;
43$           ASSIGN:        Picture=Picture.Box:NEXT(92$);


;
;
;     Model statements for module:  BasicProcess.Decide 28 (probability of buying the item from this main shop visit)
;
92$           BRANCH,        1:
                             With,(mainpercentage)/100,322$,Yes:
                             Else,323$,Yes;
322$          ASSIGN:        probability of buying the item from this main shop visit.NumberOut True=
                             probability of buying the item from this main shop visit.NumberOut True + 1:NEXT(219$);

323$          ASSIGN:        probability of buying the item from this main shop visit.NumberOut False=
                             probability of buying the item from this main shop visit.NumberOut False + 1:NEXT(220$);


;
;
;     Model statements for module:  BasicProcess.Assign 128 (Assign 128)
;
219$          ASSIGN:        deneme1=deneme1+1:NEXT(173$);


;
;
;     Model statements for module:  BasicProcess.Decide 57 (Check if list making is on)
;
173$          BRANCH,        1:
                             With,(fridgefreezercheck)/100,324$,Yes:
                             Else,325$,Yes;
324$          ASSIGN:        Check if list making is on.NumberOut True=Check if list making is on.NumberOut True + 1:NEXT(177$);

325$          ASSIGN:        Check if list making is on.NumberOut False=Check if list making is on.NumberOut False + 1
                             :NEXT(195$);


;
;
;     Model statements for module:  BasicProcess.Decide 60 (check if number of packages regularly purchased is more than two)
;
177$          BRANCH,        1:
                             If,numberofpacks>2,326$,Yes:
                             Else,327$,Yes;
326$          ASSIGN:        check if number of packages regularly purchased is more than two.NumberOut True=
                             check if number of packages regularly purchased is more than two.NumberOut True + 1:NEXT(174$);

327$          ASSIGN:        check if number of packages regularly purchased is more than two.NumberOut False=
                             check if number of packages regularly purchased is more than two.NumberOut False + 1:NEXT(179$);


;
;
;     Model statements for module:  BasicProcess.Decide 58 (Update number of packages to be purchased)
;
174$          BRANCH,        1:
                             If,currentamount>size+size/2,193$,Yes:
                             If,currentamount>size/2,194$,Yes:
                             Else,195$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 114 (Update number of mainshop visits 3)
;
195$          ASSIGN:        mainshopvisit=mainshopvisit+1:NEXT(10$);


;
;
;     Model statements for module:  BasicProcess.Separate 3 (Number of packages purchased at main shop)
;
10$           DUPLICATE,     100 - 50:
                             numberofpacks-1,332$,50:NEXT(331$);

331$          ASSIGN:        Number of packages purchased at main shop.NumberOut Orig=
                             Number of packages purchased at main shop.NumberOut Orig + 1:NEXT(7$);

332$          ASSIGN:        Number of packages purchased at main shop.NumberOut Dup=
                             Number of packages purchased at main shop.NumberOut Dup + 1:NEXT(7$);


;
;
;     Model statements for module:  BasicProcess.Assign 9 (Assign package size)
;
7$            ASSIGN:        packsize=size:NEXT(200$);


;
;
;     Model statements for module:  BasicProcess.Assign 117 (Calculate the amount purchased from main shop visits)
;
200$          ASSIGN:        totalmainshoppurchase=totalmainshoppurchase+packsize:NEXT(9$);


;
;
;     Model statements for module:  BasicProcess.Assign 13 (Assign the purchase date and shelflife and update current amount in house)
;
9$            ASSIGN:        buydate=ANINT(DaysToBaseTime(TNOW)):
                             ShelfLife=ANINT(itemshelflife):
                             currentamount=currentamount+packsize:
                             totalpurchased=totalpurchased+packsize:
                             numberofpackagespurchased=numberofpackagespurchased+1:
                             opendate=999999:NEXT(216$);


;
;
;     Model statements for module:  BasicProcess.Decide 73 (Decide 73)
;
216$          BRANCH,        1:
                             If,ShelfLife<=0,333$,Yes:
                             Else,334$,Yes;
333$          ASSIGN:        Decide 73.NumberOut True=Decide 73.NumberOut True + 1:NEXT(218$);

334$          ASSIGN:        Decide 73.NumberOut False=Decide 73.NumberOut False + 1:NEXT(66$);


;
;
;     Model statements for module:  BasicProcess.Assign 127 (Assign 127)
;
218$          ASSIGN:        minusdate=minusdate+1:NEXT(217$);


;
;
;     Model statements for module:  BasicProcess.Assign 126 (Assign new shelf life)
;
217$          ASSIGN:        ShelfLife=ANINT(itemshelflife):NEXT(216$);


;
;
;     Model statements for module:  BasicProcess.Decide 21 (Freeze right after purchasing probability)
;
66$           BRANCH,        1:
                             With,(freezeprobability)/100,335$,Yes:
                             Else,336$,Yes;
335$          ASSIGN:        Freeze right after purchasing probability.NumberOut True=
                             Freeze right after purchasing probability.NumberOut True + 1:NEXT(182$);

336$          ASSIGN:        Freeze right after purchasing probability.NumberOut False=
                             Freeze right after purchasing probability.NumberOut False + 1:NEXT(11$);


;
;
;     Model statements for module:  BasicProcess.Assign 108 (count bottles going to freezer)
;
182$          ASSIGN:        bottlesgoingfreezer=bottlesgoingfreezer+1:NEXT(223$);


;
;
;     Model statements for module:  BasicProcess.Decide 79 (Check if freeze by portion is on)
;
223$          BRANCH,        1:
                             If,freezebyportion==1,337$,Yes:
                             Else,338$,Yes;
337$          ASSIGN:        Check if freeze by portion is on.NumberOut True=Check if freeze by portion is on.NumberOut True + 1
                             :NEXT(221$);

338$          ASSIGN:        Check if freeze by portion is on.NumberOut False=
                             Check if freeze by portion is on.NumberOut False + 1:NEXT(84$);


;
;
;     Model statements for module:  BasicProcess.Separate 16 (Split portions)
;
221$          DUPLICATE,     100 - 50:
                             packsize-1,341$,50:NEXT(340$);

340$          ASSIGN:        Split portions.NumberOut Orig=Split portions.NumberOut Orig + 1:NEXT(222$);

341$          ASSIGN:        Split portions.NumberOut Dup=Split portions.NumberOut Dup + 1:NEXT(222$);


;
;
;     Model statements for module:  BasicProcess.Assign 137 (Assign package size to 1)
;
222$          ASSIGN:        packsize=1:NEXT(84$);


;
;
;     Model statements for module:  BasicProcess.Assign 52 (Change picture freeze)
;
84$           ASSIGN:        Picture=Picture.Box:
                             bottlesgoingfreezer=bottlesgoingfreezer+1:NEXT(205$);


;
;
;     Model statements for module:  BasicProcess.Assign 120 (Calculate total amount frozen)
;
205$          ASSIGN:        totalfrozen=totalfrozen+packsize:
                             currentfrozen=currentfrozen+packsize:NEXT(67$);


;
;
;     Model statements for module:  BasicProcess.Assign 42 (Update the shelf life)
;
67$           ASSIGN:        ShelfLife=frozenshelflife:NEXT(68$);


;
;
;     Model statements for module:  AdvancedProcess.Hold 10 (Unopened packages in freezer)
;
68$           QUEUE,         Unopened packages in freezer.Queue;
              WAIT:          3,1:NEXT(71$);


;
;
;     Model statements for module:  BasicProcess.Assign 45 (Set open shelf life for thawed item)
;
71$           ASSIGN:        onceopen=thawedshelflife:
                             packagesoutoffreezer=packagesoutoffreezer+1:
                             totalthawed=totalthawed+packsize:
                             currentfrozen=currentfrozen-packsize:NEXT(151$);


;
;
;     Model statements for module:  BasicProcess.Assign 100 (Assign label that it was a frozen item)
;
151$          ASSIGN:        frozen=1:NEXT(13$);


;
;
;     Model statements for module:  BasicProcess.Decide 9 (Check for the shelf life)
;
13$           BRANCH,        1:
                             If,(ANINT(DaysToBaseTime(TNOW))-buydate)  <=  ShelfLife,342$,Yes:
                             Else,343$,Yes;
342$          ASSIGN:        Check for the shelf life.NumberOut True=Check for the shelf life.NumberOut True + 1:NEXT(269$);

343$          ASSIGN:        Check for the shelf life.NumberOut False=Check for the shelf life.NumberOut False + 1:NEXT(212$);


;
;
;     Model statements for module:  BasicProcess.Decide 142 (Cook the whole pack and store leftovers?)
;
269$          BRANCH,        1:
                             With,(storeleftovers)/100,344$,Yes:
                             Else,345$,Yes;
344$          ASSIGN:        Cook the whole pack and store leftovers?.NumberOut True=
                             Cook the whole pack and store leftovers?.NumberOut True + 1:NEXT(19$);

345$          ASSIGN:        Cook the whole pack and store leftovers?.NumberOut False=
                             Cook the whole pack and store leftovers?.NumberOut False + 1:NEXT(270$);


;
;
;     Model statements for module:  BasicProcess.Assign 15 (Update current amount in open package and current open package buydate shelflife and  opendate in case of storing leftovers)
;
19$           ASSIGN:        currentopenamount=currentopenamount+packsize:
                             currentopenpackbuydate=buydate:
                             currentopenpackopendate=ANINT(DaysToBaseTime(TNOW)):
                             onceopen=leftovershelflife:
                             thawed=frozen:
                             currentopenpackshelflife=ShelfLife:NEXT(312$);


;
;
;     Model statements for module:  BasicProcess.Decide 160 (Check if it is an already opened package)
;
312$          BRANCH,        1:
                             If,usetobeopened==1,346$,Yes:
                             Else,347$,Yes;
346$          ASSIGN:        Check if it is an already opened package.NumberOut True=
                             Check if it is an already opened package.NumberOut True + 1:NEXT(313$);

347$          ASSIGN:        Check if it is an already opened package.NumberOut False=
                             Check if it is an already opened package.NumberOut False + 1:NEXT(27$);


;
;
;     Model statements for module:  BasicProcess.Assign 163 (Update open date)
;
313$          ASSIGN:        currentopenpackopendate=opendate:NEXT(27$);


;
;
;     Model statements for module:  AdvancedProcess.Signal 3 (New package open)
;
27$           SIGNAL:        2:NEXT(21$);


;
;
;     Model statements for module:  BasicProcess.Dispose 9 (Dispose 9)
;
21$           ASSIGN:        Dispose 9.NumberOut=Dispose 9.NumberOut + 1;
348$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Assign 142 (Update current amount in open package and current open package buydate shelflife and  opendate)
;
270$          ASSIGN:        currentopenamount=currentopenamount+packsize:
                             currentopenpackbuydate=buydate:
                             currentopenpackopendate=ANINT(DaysToBaseTime(TNOW)):
                             currentopenpackshelflife=ShelfLife:
                             thawed=frozen:NEXT(312$);


;
;
;     Model statements for module:  BasicProcess.Assign 122 (Assign 122)
;
212$          ASSIGN:        aaaa=aaaa+1:NEXT(16$);


;
;
;     Model statements for module:  BasicProcess.Separate 4 (Separate 4)
;
16$           DUPLICATE,     100 - 50:
                             1,351$,50:NEXT(350$);

350$          ASSIGN:        Separate 4.NumberOut Orig=Separate 4.NumberOut Orig + 1:NEXT(152$);

351$          ASSIGN:        Separate 4.NumberOut Dup=Separate 4.NumberOut Dup + 1:NEXT(15$);


;
;
;     Model statements for module:  BasicProcess.Decide 56 (is it from freezer or fridge pantry)
;
152$          BRANCH,        1:
                             If,frozen==1,352$,Yes:
                             Else,353$,Yes;
352$          ASSIGN:        is it from freezer or fridge pantry.NumberOut True=
                             is it from freezer or fridge pantry.NumberOut True + 1:NEXT(153$);

353$          ASSIGN:        is it from freezer or fridge pantry.NumberOut False=
                             is it from freezer or fridge pantry.NumberOut False + 1:NEXT(154$);


;
;
;     Model statements for module:  BasicProcess.Assign 101 (Waste from freezer)
;
153$          ASSIGN:        totalwastefromfreezer=totalwastefromfreezer+packsize:NEXT(35$);


;
;
;     Model statements for module:  BasicProcess.Assign 26 (Update total waste)
;
35$           ASSIGN:        totalwaste=totalwaste+packsize:
                             totalwasteexpdate=totalwasteexpdate+packsize:
                             currentamount=currentamount-packsize:NEXT(14$);


;
;
;     Model statements for module:  BasicProcess.Dispose 6 (wasted packages)
;
14$           ASSIGN:        wasted packages.NumberOut=wasted packages.NumberOut + 1;
354$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Assign 102 (Waste from fridge)
;
154$          ASSIGN:        totalwastefromfridge=totalwastefromfridge+packsize:NEXT(35$);


;
;
;     Model statements for module:  BasicProcess.Decide 10 (Is there another unopened package in the fridge or shelf)
;
15$           BRANCH,        1:
                             If,NQ(Unopened packages.Queue) >0,355$,Yes:
                             Else,356$,Yes;
355$          ASSIGN:        Is there another unopened package in the fridge or shelf.NumberOut True=
                             Is there another unopened package in the fridge or shelf.NumberOut True + 1:NEXT(17$);

356$          ASSIGN:        Is there another unopened package in the fridge or shelf.NumberOut False=
                             Is there another unopened package in the fridge or shelf.NumberOut False + 1:NEXT(72$);


;
;
;     Model statements for module:  AdvancedProcess.Signal 1 (Open another pack)
;
17$           SIGNAL:        1:NEXT(18$);


;
;
;     Model statements for module:  BasicProcess.Dispose 8 (Dispose 8)
;
18$           ASSIGN:        Dispose 8.NumberOut=Dispose 8.NumberOut + 1;
357$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Decide 22 (Is there another unopened package in the freezer)
;
72$           BRANCH,        1:
                             If,NQ(Unopened packages in freezer.Queue)  > 0,358$,Yes:
                             Else,359$,Yes;
358$          ASSIGN:        Is there another unopened package in the freezer.NumberOut True=
                             Is there another unopened package in the freezer.NumberOut True + 1:NEXT(73$);

359$          ASSIGN:        Is there another unopened package in the freezer.NumberOut False=
                             Is there another unopened package in the freezer.NumberOut False + 1:NEXT(31$);


;
;
;     Model statements for module:  AdvancedProcess.Signal 5 (Open another bottle from the freezer)
;
73$           SIGNAL:        3:NEXT(18$);


;
;
;     Model statements for module:  AdvancedProcess.Signal 4 (No packs left)
;
31$           SIGNAL:        2:NEXT(18$);


;
;
;     Model statements for module:  AdvancedProcess.Hold 6 (Unopened packages)
;
11$           QUEUE,         Unopened packages.Queue;
              WAIT:          1,1:NEXT(70$);


;
;
;     Model statements for module:  BasicProcess.Assign 44 (Set open shelf life to original)
;
70$           ASSIGN:        onceopen=onceopenusewithin:NEXT(13$);


;
;
;     Model statements for module:  BasicProcess.Assign 112 (Update number of mainshop visits)
;
193$          ASSIGN:        mainshopvisit=mainshopvisit+1:NEXT(175$);


;
;
;     Model statements for module:  BasicProcess.Separate 13 (Number of packages purchased at main shop altered)
;
175$          DUPLICATE,     100 - 50:
                             numberofpacks-3,362$,50:NEXT(361$);

361$          ASSIGN:        Number of packages purchased at main shop altered.NumberOut Orig=
                             Number of packages purchased at main shop altered.NumberOut Orig + 1:NEXT(7$);

362$          ASSIGN:        Number of packages purchased at main shop altered.NumberOut Dup=
                             Number of packages purchased at main shop altered.NumberOut Dup + 1:NEXT(7$);


;
;
;     Model statements for module:  BasicProcess.Assign 113 (Update number of mainshop visits 2)
;
194$          ASSIGN:        mainshopvisit=mainshopvisit+1:NEXT(176$);


;
;
;     Model statements for module:  BasicProcess.Separate 14 (Number of packages purchased at main shop altered again)
;
176$          DUPLICATE,     100 - 50:
                             numberofpacks-2,365$,50:NEXT(364$);

364$          ASSIGN:        Number of packages purchased at main shop altered again.NumberOut Orig=
                             Number of packages purchased at main shop altered again.NumberOut Orig + 1:NEXT(7$);

365$          ASSIGN:        Number of packages purchased at main shop altered again.NumberOut Dup=
                             Number of packages purchased at main shop altered again.NumberOut Dup + 1:NEXT(7$);


;
;
;     Model statements for module:  BasicProcess.Decide 62 (Check if regularly two packages are purchased)
;
179$          BRANCH,        1:
                             If,numberofpacks==2,366$,Yes:
                             Else,367$,Yes;
366$          ASSIGN:        Check if regularly two packages are purchased.NumberOut True=
                             Check if regularly two packages are purchased.NumberOut True + 1:NEXT(178$);

367$          ASSIGN:        Check if regularly two packages are purchased.NumberOut False=
                             Check if regularly two packages are purchased.NumberOut False + 1:NEXT(181$);


;
;
;     Model statements for module:  BasicProcess.Decide 61 (Update number of packages to be purchased in case only two packages regularly purchased)
;
178$          BRANCH,        1:
                             If,currentamount>size+size/2,180$,Yes:
                             If,currentamount>size/2,194$,Yes:
                             Else,195$,Yes;

;
;
;     Model statements for module:  BasicProcess.Dispose 29 (Do not purchase any)
;
180$          ASSIGN:        Do not purchase any.NumberOut=Do not purchase any.NumberOut + 1;
370$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Decide 63 (Update number of packages to be purchased in case only one package regularly purchased)
;
181$          BRANCH,        1:
                             If,currentamount>size/2,180$,Yes:
                             Else,195$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 129 (Assign 129)
;
220$          ASSIGN:        deneme2=deneme2+1:NEXT(45$);


;
;
;     Model statements for module:  BasicProcess.Dispose 12 (Dispose 12)
;
45$           ASSIGN:        Dispose 12.NumberOut=Dispose 12.NumberOut + 1;
373$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Assign 31 (Tuesday)
;
39$           ASSIGN:        shop=3:NEXT(47$);


;
;
;     Model statements for module:  BasicProcess.Assign 32 (Wednesday)
;
40$           ASSIGN:        shop=4:NEXT(47$);


;
;
;     Model statements for module:  BasicProcess.Create 2 (Opportunity to Consume for Breakfast)
;

374$          CREATE,        opportunitynumberbreakfast*people,DaysToBaseTime(0.2),teacoffee:
                             DaysToBaseTime(opportunitybreakfast):NEXT(375$);

375$          ASSIGN:        Opportunity to Consume for Breakfast.NumberOut=Opportunity to Consume for Breakfast.NumberOut + 1
                             :NEXT(0$);


;
;
;     Model statements for module:  BasicProcess.Decide 2 (Probability of Consumption for Breakfast)
;
0$            BRANCH,        1:
                             With,(probabilitybreakfast)/100,378$,Yes:
                             Else,379$,Yes;
378$          ASSIGN:        Probability of Consumption for Breakfast.NumberOut True=
                             Probability of Consumption for Breakfast.NumberOut True + 1:NEXT(4$);

379$          ASSIGN:        Probability of Consumption for Breakfast.NumberOut False=
                             Probability of Consumption for Breakfast.NumberOut False + 1:NEXT(240$);


;
;
;     Model statements for module:  BasicProcess.Assign 2 (Consumption amount for breakfast)
;
4$            ASSIGN:        consume=ANINT(consumptionbreakfast):NEXT(275$);


;
;
;     Model statements for module:  BasicProcess.Decide 145 (Check if behaviour change is on)
;
275$          BRANCH,        1:
                             If,behaviourchange==1,380$,Yes:
                             Else,381$,Yes;
380$          ASSIGN:        Check if behaviour change is on.NumberOut True=Check if behaviour change is on.NumberOut True + 1
                             :NEXT(281$);

381$          ASSIGN:        Check if behaviour change is on.NumberOut False=Check if behaviour change is on.NumberOut False + 1
                             :NEXT(49$);


;
;
;     Model statements for module:  BasicProcess.Decide 154 (Check if the open pack has 1 day to expire)
;
281$          BRANCH,        1:
                             If,
                             (ANINT(DaysToBaseTime(TNOW))-currentopenpackbuydate)-currentopenpackshelflife == -1 && (currentamount > (avgdailyconsumption)*threshold),
                             284$,Yes:
                             If,
                             (ANINT(DaysToBaseTime(TNOW))-currentopenpackopendate)-onceopen == -1 && (currentamount > (avgdailyconsumption)*threshold),
                             284$,Yes:
                             Else,294$,Yes;

;
;
;     Model statements for module:  AdvancedProcess.Search 7 (Search packs that has 1 day to expiration)
;
294$          SEARCH,        Unopened packages.Queue,1,NQ:ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == -1;
384$          BRANCH,        1:
                             If,J<>0,385$,Yes:
                             Else,386$,Yes;
385$          DELAY:         0.0,,VA:NEXT(291$);

386$          DELAY:         0.0,,VA:NEXT(282$);


;
;
;     Model statements for module:  BasicProcess.Decide 157 (Check if there is an already opened package)
;
291$          BRANCH,        1:
                             If,currentopenamount == 0,387$,Yes:
                             Else,388$,Yes;
387$          ASSIGN:        Check if there is an already opened package.NumberOut True=
                             Check if there is an already opened package.NumberOut True + 1:NEXT(284$);

388$          ASSIGN:        Check if there is an already opened package.NumberOut False=
                             Check if there is an already opened package.NumberOut False + 1:NEXT(292$);


;
;
;     Model statements for module:  BasicProcess.Assign 153 (Update consumption amount 1)
;
284$          ASSIGN:        consume=ANINT(consume*(1+ increase1/100)):NEXT(287$);


;
;
;     Model statements for module:  BasicProcess.Assign 156 (Assign 156)
;
287$          ASSIGN:        count1=count1+1:NEXT(49$);


;
;
;     Model statements for module:  BasicProcess.Assign 35 (Calculate total requirement)
;
49$           ASSIGN:        totalrequirement=totalrequirement+consume:NEXT(8$);


;
;
;     Model statements for module:  BasicProcess.Decide 7 (Check if there is enough in the open package)
;
8$            BRANCH,        1:
                             If,currentopenamount>=consume,389$,Yes:
                             Else,390$,Yes;
389$          ASSIGN:        Check if there is enough in the open package.NumberOut True=
                             Check if there is enough in the open package.NumberOut True + 1:NEXT(23$);

390$          ASSIGN:        Check if there is enough in the open package.NumberOut False=
                             Check if there is enough in the open package.NumberOut False + 1:NEXT(30$);


;
;
;     Model statements for module:  BasicProcess.Assign 18 (Current open package open date shelf life and exp date)
;
23$           ASSIGN:        opendate=currentopenpackopendate:
                             buydate=currentopenpackbuydate:
                             ShelfLife=currentopenpackshelflife:
                             freezedbefore=thawed:NEXT(183$);


;
;
;     Model statements for module:  BasicProcess.Decide 64 (Check if the bottle was frozen before)
;
183$          BRANCH,        1:
                             If,freezedbefore==1,391$,Yes:
                             Else,392$,Yes;
391$          ASSIGN:        Check if the bottle was frozen before.NumberOut True=
                             Check if the bottle was frozen before.NumberOut True + 1:NEXT(207$);

392$          ASSIGN:        Check if the bottle was frozen before.NumberOut False=
                             Check if the bottle was frozen before.NumberOut False + 1:NEXT(24$);


;
;
;     Model statements for module:  BasicProcess.Decide 69 (Decide 69)
;
207$          BRANCH,        1:
                             If,(ANINT(DaysToBaseTime(TNOW))-buydate)  >  ShelfLife,184$,Yes:
                             If,(ANINT(DaysToBaseTime(TNOW))-opendate) > onceopen,184$,Yes:
                             Else,22$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 17 (Consume the food item)
;
22$           ASSIGN:        currentopenamount=currentopenamount-consume:
                             totalconsumption=totalconsumption+consume:
                             currentamount=currentamount-consume:NEXT(26$);


;
;
;     Model statements for module:  BasicProcess.Dispose 10 (Consumed)
;
26$           ASSIGN:        Consumed.NumberOut=Consumed.NumberOut + 1;
395$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Assign 109 (Waste from a previously frozen bottle aka thawed shelf life)
;
184$          ASSIGN:        totalwastefromfrozenbottle=totalwastefromfrozenbottle+currentopenamount:NEXT(25$);


;
;
;     Model statements for module:  BasicProcess.Assign 21 (Calculate total waste and throw the package)
;
25$           ASSIGN:        totalwaste=totalwaste+currentopenamount:
                             totalwastefromfridge=totalwastefromfridge+currentopenamount:
                             currentamount=currentamount-currentopenamount:
                             currentopenamount=0:NEXT(36$);


;
;
;     Model statements for module:  BasicProcess.Decide 14 (Is there another unopen package in fridge or shelf)
;
36$           BRANCH,        1:
                             If,NQ(unopened packages.Queue) > 0,396$,Yes:
                             Else,397$,Yes;
396$          ASSIGN:        Is there another unopen package in fridge or shelf.NumberOut True=
                             Is there another unopen package in fridge or shelf.NumberOut True + 1:NEXT(20$);

397$          ASSIGN:        Is there another unopen package in fridge or shelf.NumberOut False=
                             Is there another unopen package in fridge or shelf.NumberOut False + 1:NEXT(74$);


;
;
;     Model statements for module:  AdvancedProcess.Signal 2 (Open a new pack)
;
20$           SIGNAL:        1:NEXT(28$);


;
;
;     Model statements for module:  AdvancedProcess.Hold 8 (Wait until the pack opens)
;
28$           QUEUE,         Wait until the pack opens.Queue;
              WAIT:          2:NEXT(32$);


;
;
;     Model statements for module:  BasicProcess.Decide 13 (A new pack opened?)
;
32$           BRANCH,        1:
                             If,currentopenamount>=consume,22$,Yes:
                             If,currentopenamount>0,88$,Yes:
                             Else,33$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 25 (Requirement notfullfilled)
;
33$           ASSIGN:        reqnotfulfilled=reqnotfulfilled+consume:NEXT(34$);


;
;
;     Model statements for module:  BasicProcess.Dispose 11 (Req Not Fulfilled)
;
34$           ASSIGN:        Req Not Fulfilled.NumberOut=Req Not Fulfilled.NumberOut + 1;
400$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Assign 55 (Calculate how many more is needed)
;
88$           ASSIGN:        totalconsumption=totalconsumption+currentopenamount:
                             currentamount=currentamount-currentopenamount:
                             consume=consume-currentopenamount:
                             currentopenamount=0:NEXT(36$);


;
;
;     Model statements for module:  BasicProcess.Decide 23 (Is there another pack in the freezer)
;
74$           BRANCH,        1:
                             If,NQ(Unopened packages in freezer.Queue)  > 0,401$,Yes:
                             Else,402$,Yes;
401$          ASSIGN:        Is there another pack in the freezer.NumberOut True=
                             Is there another pack in the freezer.NumberOut True + 1:NEXT(102$);

402$          ASSIGN:        Is there another pack in the freezer.NumberOut False=
                             Is there another pack in the freezer.NumberOut False + 1:NEXT(94$);


;
;
;     Model statements for module:  BasicProcess.Decide 40 (Probaility of using the freezer)
;
102$          BRANCH,        1:
                             With,(probabilityfreezer)/100,403$,Yes:
                             Else,404$,Yes;
403$          ASSIGN:        Probaility of using the freezer.NumberOut True=Probaility of using the freezer.NumberOut True + 1
                             :NEXT(75$);

404$          ASSIGN:        Probaility of using the freezer.NumberOut False=Probaility of using the freezer.NumberOut False + 1
                             :NEXT(103$);


;
;
;     Model statements for module:  AdvancedProcess.Signal 6 (Open a new pack from the freezer)
;
75$           SIGNAL:        3:NEXT(28$);


;
;
;     Model statements for module:  BasicProcess.Assign 66 (Calculate requirement notfulfilled because of choosing not to check freezer)
;
103$          ASSIGN:        reqnotfulfilledfreezer=reqnotfulfilledfreezer+consume:NEXT(33$);


;
;
;     Model statements for module:  BasicProcess.Decide 31 (Is it for cooking)
;
94$           BRANCH,        1:
                             If,forcooking==1,405$,Yes:
                             Else,406$,Yes;
405$          ASSIGN:        Is it for cooking.NumberOut True=Is it for cooking.NumberOut True + 1:NEXT(128$);

406$          ASSIGN:        Is it for cooking.NumberOut False=Is it for cooking.NumberOut False + 1:NEXT(33$);


;
;
;     Model statements for module:  BasicProcess.Decide 50 (Decide 50)
;
128$          BRANCH,        1:
                             If,(consume/size)-ANINT(consume/size) >= 0.5,407$,Yes:
                             Else,408$,Yes;
407$          ASSIGN:        Decide 50.NumberOut True=Decide 50.NumberOut True + 1:NEXT(101$);

408$          ASSIGN:        Decide 50.NumberOut False=Decide 50.NumberOut False + 1:NEXT(129$);


;
;
;     Model statements for module:  BasicProcess.Assign 65 (Calculate how many packages are needed)
;
101$          ASSIGN:        packagesneeded=ANINT(consume/size):NEXT(124$);


;
;
;     Model statements for module:  BasicProcess.Separate 11 (Separate 11)
;
124$          DUPLICATE,     100 - 50:
                             1,411$,50:NEXT(410$);

410$          ASSIGN:        Separate 11.NumberOut Orig=Separate 11.NumberOut Orig + 1:NEXT(123$);

411$          ASSIGN:        Separate 11.NumberOut Dup=Separate 11.NumberOut Dup + 1:NEXT(125$);


;
;
;     Model statements for module:  BasicProcess.Assign 82 (Assign 82)
;
123$          ASSIGN:        special=2:NEXT(105$);


;
;
;     Model statements for module:  AdvancedTransfer.Route 1 (Go to topup to buy missing amount)
;
105$          ROUTE:         0.000000000000000,Station 1;


;
;
;     Model statements for module:  AdvancedTransfer.Route 8 (Once it is purchased continue cooking)
;
125$          ROUTE:         0.000000000000000,continuecooking;


;
;
;     Model statements for module:  BasicProcess.Assign 83 (Calculate how many packages are needed 2)
;
129$          ASSIGN:        packagesneeded=ANINT(consume/size)+1:NEXT(124$);


;
;
;     Model statements for module:  BasicProcess.Decide 12 (Decide 12)
;
24$           BRANCH,        1:
                             If,(ANINT(DaysToBaseTime(TNOW))-buydate)  >  ShelfLife,145$,Yes:
                             If,(ANINT(DaysToBaseTime(TNOW))-opendate) > onceopen,146$,Yes:
                             Else,22$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 93 (Waste from expiration date)
;
145$          ASSIGN:        totalwasteexpdate=totalwasteexpdate+currentopenamount:NEXT(25$);


;
;
;     Model statements for module:  BasicProcess.Assign 94 (Waste from open shelf life)
;
146$          ASSIGN:        totalwasteopenshelflife=totalwasteopenshelflife+currentopenamount:NEXT(25$);


;
;
;     Model statements for module:  BasicProcess.Assign 24 (Calculate how much more is needed)
;
30$           ASSIGN:        consume=consume-currentopenamount:
                             currentamount=currentamount-currentopenamount:
                             totalconsumption=totalconsumption+currentopenamount:
                             currentopenamount=0:NEXT(36$);


;
;
;     Model statements for module:  BasicProcess.Assign 160 (Closed the open pack to consume the pack that is about to expire)
;
292$          ASSIGN:        buydate=currentopenpackbuydate:
                             ShelfLife=currentopenpackshelflife:
                             packsize=currentopenamount:
                             opendate=currentopenpackopendate:
                             currentopenamount=0:
                             usetobeopened=1:NEXT(295$);


;
;
;     Model statements for module:  BasicProcess.Separate 17 (Separate 17)
;
295$          DUPLICATE,     100 - 50:
                             1,416$,50:NEXT(415$);

415$          ASSIGN:        Separate 17.NumberOut Orig=Separate 17.NumberOut Orig + 1:NEXT(296$);

416$          ASSIGN:        Separate 17.NumberOut Dup=Separate 17.NumberOut Dup + 1:NEXT(293$);


;
;
;     Model statements for module:  AdvancedTransfer.Route 10 (Route 10)
;
296$          ROUTE:         0.000000000000000,Fridge;


;
;
;     Model statements for module:  AdvancedProcess.Search and Remove 10 (Open the package that has 1 day to expiration)
;
293$          SEARCH,        Unopened packages.Queue,1,NQ(Unopened packages.Queue):
                             ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == -1;
437$          BRANCH,        1:
                             If,J<>0,419$,Yes:
                             Else,418$,Yes;
419$          REMOVE:        J,Unopened packages.Queue,openpack;
421$          ASSIGN:        Open the package that has 1 day to expiration.NumberRemoved=
                             Open the package that has 1 day to expiration.NumberRemoved + 1;
418$          DELAY:         0.0,,VA:NEXT(297$);


;
;
;     Model statements for module:  AdvancedProcess.Delay 5 (Delay 5)
;
297$          DELAY:         0.000001157407407,,Other:NEXT(284$);


;
;
;     Model statements for module:  BasicProcess.Decide 155 (Check if the open pack has 2 days to expire)
;
282$          BRANCH,        1:
                             If,
                             (ANINT(DaysToBaseTime(TNOW))-currentopenpackbuydate)- currentopenpackshelflife == -2 && (currentamount > (avgdailyconsumption*2)*threshold),
                             285$,Yes:
                             If,
                             (ANINT(DaysToBaseTime(TNOW))-currentopenpackopendate) - onceopen ==-2 && (currentamount > (avgdailyconsumption*2)*threshold),
                             285$,Yes:
                             Else,301$,Yes;

;
;
;     Model statements for module:  AdvancedProcess.Search 8 (Search packs that has 2 day to expiration)
;
301$          SEARCH,        Unopened packages.Queue,1,NQ:ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == -2;
440$          BRANCH,        1:
                             If,J<>0,441$,Yes:
                             Else,442$,Yes;
441$          DELAY:         0.0,,VA:NEXT(298$);

442$          DELAY:         0.0,,VA:NEXT(283$);


;
;
;     Model statements for module:  BasicProcess.Decide 158 (Check if there is an already opened package 2)
;
298$          BRANCH,        1:
                             If,currentopenamount == 0,443$,Yes:
                             Else,444$,Yes;
443$          ASSIGN:        Check if there is an already opened package 2.NumberOut True=
                             Check if there is an already opened package 2.NumberOut True + 1:NEXT(285$);

444$          ASSIGN:        Check if there is an already opened package 2.NumberOut False=
                             Check if there is an already opened package 2.NumberOut False + 1:NEXT(299$);


;
;
;     Model statements for module:  BasicProcess.Assign 154 (Update consumption amount 2)
;
285$          ASSIGN:        consume=ANINT(consume*(1+ increase2/100)):NEXT(288$);


;
;
;     Model statements for module:  BasicProcess.Assign 157 (Assign 157)
;
288$          ASSIGN:        count2=count2+1:NEXT(49$);


;
;
;     Model statements for module:  BasicProcess.Assign 161 (Closed the open pack to consume the pack that is about to expire 2)
;
299$          ASSIGN:        buydate=currentopenpackbuydate:
                             ShelfLife=currentopenpackshelflife:
                             packsize=currentopenamount:
                             opendate=currentopenpackopendate:
                             currentopenamount=0:
                             usetobeopened=1:NEXT(302$);


;
;
;     Model statements for module:  BasicProcess.Separate 18 (Separate 18)
;
302$          DUPLICATE,     100 - 50:
                             1,447$,50:NEXT(446$);

446$          ASSIGN:        Separate 18.NumberOut Orig=Separate 18.NumberOut Orig + 1:NEXT(303$);

447$          ASSIGN:        Separate 18.NumberOut Dup=Separate 18.NumberOut Dup + 1:NEXT(300$);


;
;
;     Model statements for module:  AdvancedTransfer.Route 11 (Route 11)
;
303$          ROUTE:         0.000000000000000,Fridge;


;
;
;     Model statements for module:  AdvancedProcess.Search and Remove 11 (Open the package that has 2 day to expiration)
;
300$          SEARCH,        Unopened packages.Queue,1,NQ(Unopened packages.Queue):
                             ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == -2;
468$          BRANCH,        1:
                             If,J<>0,450$,Yes:
                             Else,449$,Yes;
450$          REMOVE:        J,Unopened packages.Queue,openpack;
452$          ASSIGN:        Open the package that has 2 day to expiration.NumberRemoved=
                             Open the package that has 2 day to expiration.NumberRemoved + 1;
449$          DELAY:         0.0,,VA:NEXT(304$);


;
;
;     Model statements for module:  AdvancedProcess.Delay 6 (Delay 6)
;
304$          DELAY:         0.000001157407407,,Other:NEXT(285$);


;
;
;     Model statements for module:  BasicProcess.Decide 156 (Check if the open pack has 3 days to expire)
;
283$          BRANCH,        1:
                             If,
                             (ANINT(DaysToBaseTime(TNOW))-currentopenpackbuydate)- currentopenpackshelflife == -3 && (currentamount > (avgdailyconsumption*3)*threshold),
                             286$,Yes:
                             If,
                             (ANINT(DaysToBaseTime(TNOW))-currentopenpackopendate) - onceopen ==-3 && (currentamount > (avgdailyconsumption*3)*threshold),
                             286$,Yes:
                             Else,308$,Yes;

;
;
;     Model statements for module:  AdvancedProcess.Search 9 (Search packs that has 3 day to expiration)
;
308$          SEARCH,        Unopened packages.Queue,1,NQ:ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == -3;
471$          BRANCH,        1:
                             If,J<>0,472$,Yes:
                             Else,473$,Yes;
472$          DELAY:         0.0,,VA:NEXT(305$);

473$          DELAY:         0.0,,VA:NEXT(290$);


;
;
;     Model statements for module:  BasicProcess.Decide 159 (Check if there is an already opened package 3)
;
305$          BRANCH,        1:
                             If,currentopenamount == 0,474$,Yes:
                             Else,475$,Yes;
474$          ASSIGN:        Check if there is an already opened package 3.NumberOut True=
                             Check if there is an already opened package 3.NumberOut True + 1:NEXT(286$);

475$          ASSIGN:        Check if there is an already opened package 3.NumberOut False=
                             Check if there is an already opened package 3.NumberOut False + 1:NEXT(306$);


;
;
;     Model statements for module:  BasicProcess.Assign 155 (Update consumption amount 3)
;
286$          ASSIGN:        consume=ANINT(consume*(1+ increase3/100)):NEXT(289$);


;
;
;     Model statements for module:  BasicProcess.Assign 158 (Assign 158)
;
289$          ASSIGN:        count3=count3+1:NEXT(49$);


;
;
;     Model statements for module:  BasicProcess.Assign 162 (Closed the open pack to consume the pack that is about to expire 3)
;
306$          ASSIGN:        buydate=currentopenpackbuydate:
                             ShelfLife=currentopenpackshelflife:
                             packsize=currentopenamount:
                             opendate=currentopenpackopendate:
                             currentopenamount=0:
                             usetobeopened=1:NEXT(309$);


;
;
;     Model statements for module:  BasicProcess.Separate 19 (Separate 19)
;
309$          DUPLICATE,     100 - 50:
                             1,478$,50:NEXT(477$);

477$          ASSIGN:        Separate 19.NumberOut Orig=Separate 19.NumberOut Orig + 1:NEXT(310$);

478$          ASSIGN:        Separate 19.NumberOut Dup=Separate 19.NumberOut Dup + 1:NEXT(307$);


;
;
;     Model statements for module:  AdvancedTransfer.Route 12 (Route 12)
;
310$          ROUTE:         0.000000000000000,Fridge;


;
;
;     Model statements for module:  AdvancedProcess.Search and Remove 12 (Open the package that has 3 day to expiration)
;
307$          SEARCH,        Unopened packages.Queue,1,NQ(Unopened packages.Queue):
                             ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == -3;
499$          BRANCH,        1:
                             If,J<>0,481$,Yes:
                             Else,480$,Yes;
481$          REMOVE:        J,Unopened packages.Queue,openpack;
483$          ASSIGN:        Open the package that has 3 day to expiration.NumberRemoved=
                             Open the package that has 3 day to expiration.NumberRemoved + 1;
480$          DELAY:         0.0,,VA:NEXT(311$);


;
;
;     Model statements for module:  AdvancedProcess.Delay 7 (Delay 7)
;
311$          DELAY:         0.000001157407407,,Other:NEXT(286$);


;
;
;     Model statements for module:  BasicProcess.Assign 159 (Assign 159)
;
290$          ASSIGN:        count4=count4+1:NEXT(49$);


;
;
;     Model statements for module:  BasicProcess.Dispose 33 (Dispose 33)
;
240$          ASSIGN:        Dispose 33.NumberOut=Dispose 33.NumberOut + 1;
500$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Create 3 (Opportunity to consume for Lunch)
;

501$          CREATE,        opportunitynumberlunch*people,DaysToBaseTime(0.2),cereal:DaysToBaseTime(opportunitylunch)
                             :NEXT(502$);

502$          ASSIGN:        Opportunity to consume for Lunch.NumberOut=Opportunity to consume for Lunch.NumberOut + 1:NEXT(1$);


;
;
;     Model statements for module:  BasicProcess.Decide 3 (Probability of Consumption for Lunch)
;
1$            BRANCH,        1:
                             With,(probabilitylunch)/100,505$,Yes:
                             Else,506$,Yes;
505$          ASSIGN:        Probability of Consumption for Lunch.NumberOut True=
                             Probability of Consumption for Lunch.NumberOut True + 1:NEXT(5$);

506$          ASSIGN:        Probability of Consumption for Lunch.NumberOut False=
                             Probability of Consumption for Lunch.NumberOut False + 1:NEXT(240$);


;
;
;     Model statements for module:  BasicProcess.Assign 3 (Consumption amount for lunch)
;
5$            ASSIGN:        consume=ANINT(consumptionlunch):NEXT(275$);


;
;
;     Model statements for module:  BasicProcess.Create 5 (Opportunity to consume for dinner)
;

507$          CREATE,        opportunitynumberdinner*people,DaysToBaseTime(0.2),drinking:DaysToBaseTime(opportunitydinner)
                             :NEXT(508$);

508$          ASSIGN:        Opportunity to consume for dinner.NumberOut=Opportunity to consume for dinner.NumberOut + 1
                             :NEXT(2$);


;
;
;     Model statements for module:  BasicProcess.Decide 5 (Probability of Consumption for Dinner)
;
2$            BRANCH,        1:
                             With,(probabilitydinner)/100,511$,Yes:
                             Else,512$,Yes;
511$          ASSIGN:        Probability of Consumption for Dinner.NumberOut True=
                             Probability of Consumption for Dinner.NumberOut True + 1:NEXT(6$);

512$          ASSIGN:        Probability of Consumption for Dinner.NumberOut False=
                             Probability of Consumption for Dinner.NumberOut False + 1:NEXT(240$);


;
;
;     Model statements for module:  BasicProcess.Assign 5 (Consumption amount for dinner)
;
6$            ASSIGN:        consume=ANINT(consumptiondinner):NEXT(275$);


;
;
;     Model statements for module:  BasicProcess.Create 8 (Household TopUpShop Shopping Patterns)
;

513$          CREATE,        topupon,DaysToBaseTime(0.11),Entity 1:DaysToBaseTime(topupinterval):NEXT(514$);

514$          ASSIGN:        Household TopUpShop Shopping Patterns.NumberOut=Household TopUpShop Shopping Patterns.NumberOut + 1
                             :NEXT(44$);


;
;
;     Model statements for module:  BasicProcess.Decide 16 (Check the current amount)
;
44$           BRANCH,        1:
                             If,currentamount  <= trigger && next day.WIP == 0,517$,Yes:
                             Else,518$,Yes;
517$          ASSIGN:        Check the current amount.NumberOut True=Check the current amount.NumberOut True + 1:NEXT(48$);

518$          ASSIGN:        Check the current amount.NumberOut False=Check the current amount.NumberOut False + 1:NEXT(45$);


;
;
;     Model statements for module:  BasicProcess.Decide 19 (probability of actually visiting top up shop)
;
48$           BRANCH,        1:
                             With,(topupvisitprob)/100,519$,Yes:
                             Else,520$,Yes;
519$          ASSIGN:        probability of actually visiting top up shop.NumberOut True=
                             probability of actually visiting top up shop.NumberOut True + 1:NEXT(46$);

520$          ASSIGN:        probability of actually visiting top up shop.NumberOut False=
                             probability of actually visiting top up shop.NumberOut False + 1:NEXT(50$);


;
;
;     Model statements for module:  BasicProcess.Decide 17 (Main shop occurs today?)
;
46$           BRANCH,        1:
                             If,CalDayOfWeek(TNOW) == mainshopday,521$,Yes:
                             Else,522$,Yes;
521$          ASSIGN:        Main shop occurs today?.NumberOut True=Main shop occurs today?.NumberOut True + 1:NEXT(45$);

522$          ASSIGN:        Main shop occurs today?.NumberOut False=Main shop occurs today?.NumberOut False + 1:NEXT(93$);


;
;
;     Model statements for module:  BasicProcess.Decide 29 (probability of buying the item from this top up shop visit)
;
93$           BRANCH,        1:
                             With,(topuppercentage)/100,523$,Yes:
                             Else,524$,Yes;
523$          ASSIGN:        probability of buying the item from this top up shop visit.NumberOut True=
                             probability of buying the item from this top up shop visit.NumberOut True + 1:NEXT(53$);

524$          ASSIGN:        probability of buying the item from this top up shop visit.NumberOut False=
                             probability of buying the item from this top up shop visit.NumberOut False + 1:NEXT(45$);


;
;
;     Model statements for module:  BasicProcess.Assign 39 (Change picture topup)
;
53$           ASSIGN:        Picture=Picture.Box:NEXT(196$);


;
;
;     Model statements for module:  BasicProcess.Assign 115 (Update number of topupshop visits)
;
196$          ASSIGN:        topupshopvisit=topupshopvisit+1:NEXT(52$);


;
;
;     Model statements for module:  BasicProcess.Separate 5 (Number of packages purchased at top up shop)
;
52$           DUPLICATE,     100 - 50:
                             numberofpackstopup-1,527$,50:NEXT(526$);

526$          ASSIGN:        Number of packages purchased at top up shop.NumberOut Orig=
                             Number of packages purchased at top up shop.NumberOut Orig + 1:NEXT(51$);

527$          ASSIGN:        Number of packages purchased at top up shop.NumberOut Dup=
                             Number of packages purchased at top up shop.NumberOut Dup + 1:NEXT(51$);


;
;
;     Model statements for module:  BasicProcess.Assign 38 (Assign package size top up)
;
51$           ASSIGN:        packsize=size:NEXT(201$);


;
;
;     Model statements for module:  BasicProcess.Assign 118 (Calculate the amount purchased from topup shop visits)
;
201$          ASSIGN:        totaltopupshoppurchase=totaltopupshoppurchase+packsize:NEXT(9$);


;
;
;     Model statements for module:  BasicProcess.Process 1 (next day)
;
50$           ASSIGN:        next day.NumberIn=next day.NumberIn + 1:
                             next day.WIP=next day.WIP+1;
531$          QUEUE,         next day.Queue;
530$          SEIZE,         2,VA:
                             dummy,1:NEXT(529$);

529$          DELAY:         1.00000001,,VA;
528$          RELEASE:       dummy,1;
576$          ASSIGN:        next day.NumberOut=next day.NumberOut + 1:
                             next day.WIP=next day.WIP-1:NEXT(46$);


;
;
;     Model statements for module:  AdvancedProcess.File 1 (Staples Input)
;

;
;
;     Model statements for module:  BasicProcess.Create 9 (Opportunity to consume directly adult)
;

580$          CREATE,        adult,DaysToBaseTime(0.2),drinking:DaysToBaseTime(1):NEXT(581$);

581$          ASSIGN:        Opportunity to consume directly adult.NumberOut=Opportunity to consume directly adult.NumberOut + 1
                             :NEXT(242$);


;
;
;     Model statements for module:  BasicProcess.Decide 107 (Increase consumption probability unopened adult)
;
242$          BRANCH,        1:
                             If,notemptyfridgeincrease==1,244$,Yes:
                             If,unopenedincrease==1,241$,Yes:
                             If,openedincrease==1,225$,Yes:
                             Else,55$,Yes;

;
;
;     Model statements for module:  BasicProcess.Decide 20 (Probability of Consumption adult)
;
55$           BRANCH,        1:
                             With,(probabilityadult)/100,586$,Yes:
                             Else,587$,Yes;
586$          ASSIGN:        Probability of Consumption adult.NumberOut True=Probability of Consumption adult.NumberOut True + 1
                             :NEXT(54$);

587$          ASSIGN:        Probability of Consumption adult.NumberOut False=
                             Probability of Consumption adult.NumberOut False + 1:NEXT(3$);


;
;
;     Model statements for module:  BasicProcess.Assign 40 (Consumption amount for adult)
;
54$           ASSIGN:        consume=ANINT(consumptionadult):NEXT(276$);


;
;
;     Model statements for module:  BasicProcess.Decide 149 (Decide 149)
;
276$          BRANCH,        1:
                             If,consume>0,588$,Yes:
                             Else,589$,Yes;
588$          ASSIGN:        Decide 149.NumberOut True=Decide 149.NumberOut True + 1:NEXT(98$);

589$          ASSIGN:        Decide 149.NumberOut False=Decide 149.NumberOut False + 1:NEXT(54$);


;
;
;     Model statements for module:  BasicProcess.Decide 34 (Check if current amount sufficient for consumption)
;
98$           BRANCH,        1:
                             If,currentamount>=consume,590$,Yes:
                             Else,591$,Yes;
590$          ASSIGN:        Check if current amount sufficient for consumption.NumberOut True=
                             Check if current amount sufficient for consumption.NumberOut True + 1:NEXT(275$);

591$          ASSIGN:        Check if current amount sufficient for consumption.NumberOut False=
                             Check if current amount sufficient for consumption.NumberOut False + 1:NEXT(99$);


;
;
;     Model statements for module:  BasicProcess.Decide 35 (What the household will decide to do)
;
99$           BRANCH,        1:
                             With,(probnotconsume)/100,104$,Yes:
                             With,(probconsumeavailable)/100,49$,Yes:
                             Else,100$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 64 (label for cooking 1)
;
100$          ASSIGN:        forcooking=1:NEXT(49$);


;
;
;     Model statements for module:  BasicProcess.Assign 67 (calculate the requirement not fulfilled for the consumption)
;
104$          ASSIGN:        reqnotfulfilledmissingamount=reqnotfulfilledmissingamount+consume:NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Dispose 30 (Dispose 30)
;
215$          ASSIGN:        Dispose 30.NumberOut=Dispose 30.NumberOut + 1;
594$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Dispose 2 (No consumption)
;
3$            ASSIGN:        No consumption.NumberOut=No consumption.NumberOut + 1;
595$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Decide 110 (Check if fridge is empty or not adult)
;
244$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue) >0  || currentopenamount>0,596$,Yes:
                             Else,597$,Yes;
596$          ASSIGN:        Check if fridge is empty or not adult.NumberOut True=
                             Check if fridge is empty or not adult.NumberOut True + 1:NEXT(243$);

597$          ASSIGN:        Check if fridge is empty or not adult.NumberOut False=
                             Check if fridge is empty or not adult.NumberOut False + 1:NEXT(55$);


;
;
;     Model statements for module:  BasicProcess.Decide 109 (Probability of Consumption adult increase when frisge is not empty)
;
243$          BRANCH,        1:
                             With,(probabilityadult+notemptyfridgeincreaseprob)/100,598$,Yes:
                             Else,599$,Yes;
598$          ASSIGN:        Probability of Consumption adult increase when frisge is not empty.NumberOut True=
                             Probability of Consumption adult increase when frisge is not empty.NumberOut True + 1:NEXT(54$);

599$          ASSIGN:        Probability of Consumption adult increase when frisge is not empty.NumberOut False=
                             Probability of Consumption adult increase when frisge is not empty.NumberOut False + 1:NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Decide 98 (Check if there are unopened packages in the fridge adult)
;
241$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue)  >  0,600$,Yes:
                             Else,601$,Yes;
600$          ASSIGN:        Check if there are unopened packages in the fridge adult.NumberOut True=
                             Check if there are unopened packages in the fridge adult.NumberOut True + 1:NEXT(226$);

601$          ASSIGN:        Check if there are unopened packages in the fridge adult.NumberOut False=
                             Check if there are unopened packages in the fridge adult.NumberOut False + 1:NEXT(55$);


;
;
;     Model statements for module:  BasicProcess.Decide 87 (Probability of Consumption adult increased when there are unopened packages in the fridge)
;
226$          BRANCH,        1:
                             With,(probabilityadult+unopenedincreaseprob)/100,602$,Yes:
                             Else,603$,Yes;
602$          ASSIGN:        
                             Probability of Consumption adult increased when there are unopened packages in the fridge.NumberOut True=
                             Probability of Consumption adult increased when there are unopened packages in the fridge.NumberOut True + 1
                             :NEXT(54$);

603$          ASSIGN:        
                             Probability of Consumption adult increased when there are unopened packages in the fridge.NumberOut False=
                             Probability of Consumption adult increased when there are unopened packages in the fridge.NumberOut False + 1
                             :NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Decide 84 (Check if there are opened packages in the fridge adult)
;
225$          BRANCH,        1:
                             If,currentopenamount>0,604$,Yes:
                             Else,605$,Yes;
604$          ASSIGN:        Check if there are opened packages in the fridge adult.NumberOut True=
                             Check if there are opened packages in the fridge adult.NumberOut True + 1:NEXT(245$);

605$          ASSIGN:        Check if there are opened packages in the fridge adult.NumberOut False=
                             Check if there are opened packages in the fridge adult.NumberOut False + 1:NEXT(55$);


;
;
;     Model statements for module:  BasicProcess.Decide 111 (Probability of Consumption adult increased when there are opened packages in the fridge)
;
245$          BRANCH,        1:
                             With,(probabilityadult+openedincreaseprob)/100,606$,Yes:
                             Else,607$,Yes;
606$          ASSIGN:        
                             Probability of Consumption adult increased when there are opened packages in the fridge.NumberOut True=
                             Probability of Consumption adult increased when there are opened packages in the fridge.NumberOut True + 1
                             :NEXT(54$);

607$          ASSIGN:        
                             Probability of Consumption adult increased when there are opened packages in the fridge.NumberOut False=
                             Probability of Consumption adult increased when there are opened packages in the fridge.NumberOut False + 1
                             :NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Create 10 (Create 10)
;

608$          CREATE,        1,DaysToBaseTime(Tfin),Entity 1:DaysToBaseTime(1),1:NEXT(609$);

609$          ASSIGN:        Create 10.NumberOut=Create 10.NumberOut + 1:NEXT(233$);


;
;
;     Model statements for module:  BasicProcess.Assign 140 (Assign 140)
;
233$          ASSIGN:        rep=NREP:
                             avgtimeinfreezer=TAVG(Unopened packages in freezer.Queue.WaitingTime):
                             avgtimeinfridge=TAVG(Unopened packages.Queue.WaitingTime):NEXT(56$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 1 (Write Replication Number)
;
56$           WRITE,         Staples Output,RECORDSET(Replication Number):
                             rep:NEXT(58$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 2 (Write Total Waste)
;
58$           WRITE,         Staples Output,RECORDSET(Total Waste):
                             totalwaste:NEXT(59$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 3 (Write Total Consumption)
;
59$           WRITE,         Staples Output,RECORDSET(Total Consumption):
                             totalconsumption:NEXT(60$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 4 (Write Total Requirement)
;
60$           WRITE,         Staples Output,RECORDSET(Total Requirement):
                             totalrequirement:NEXT(61$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 5 (Write Total Purchased)
;
61$           WRITE,         Staples Output,RECORDSET(Total Purchased):
                             totalpurchased:NEXT(198$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 21 (Write Total Main Shop Visits)
;
198$          WRITE,         Staples Output,RECORDSET(Number of visits to mainshop):
                             mainshopvisit:NEXT(199$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 22 (Write Total Topup Shop Visits)
;
199$          WRITE,         Staples Output,RECORDSET(Number of visits to topupshop):
                             topupshopvisit:NEXT(204$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 24 (Write Total Purchases from Main Shop Visits)
;
204$          WRITE,         Staples Output,RECORDSET(Total amount purchased from main shop visits):
                             totalmainshoppurchase:NEXT(203$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 23 (Write Total Purchases from Topup Shop Visits)
;
203$          WRITE,         Staples Output,RECORDSET(Total amount purchased from topup shop visits):
                             totaltopupshoppurchase:NEXT(206$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 25 (Write Total Amount Frozen)
;
206$          WRITE,         Staples Output,RECORDSET(Total amount frozen):
                             totalfrozen:NEXT(209$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 26 (Write Total Amount Thawed)
;
209$          WRITE,         Staples Output,RECORDSET(Total amount defrosted):
                             totalthawed:NEXT(62$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 6 (Write Total Requirement Not Fulfilled)
;
62$           WRITE,         Staples Output,RECORDSET(Requirement Not Fulfilled):
                             reqnotfulfilled:NEXT(63$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 7 (Write amount left without consumed)
;
63$           WRITE,         Staples Output,RECORDSET(amount left):
                             currentamount:NEXT(155$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 8 (Write waste caused by expiration date)
;
155$          WRITE,         Staples Output,RECORDSET(Waste cause by expiration date):
                             totalwasteexpdate:NEXT(156$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 9 (Write waste caused by open shelf life)
;
156$          WRITE,         Staples Output,RECORDSET(Waste cause by open shelf life):
                             totalwasteopenshelflife:NEXT(157$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 11 (Write waste from freezer)
;
157$          WRITE,         Staples Output,RECORDSET(Waste from freezer):
                             totalwastefromfreezer:NEXT(168$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 12 (Write waste first week)
;
168$          WRITE,         Staples Output,RECORDSET(Total waste first week):
                             firstweekwaste:NEXT(169$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 13 (Write waste second week)
;
169$          WRITE,         Staples Output,RECORDSET(Total waste second week):
                             secondweekwaste:NEXT(170$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 14 (Write waste third week)
;
170$          WRITE,         Staples Output,RECORDSET(Total waste third week):
                             thirdweekwaste:NEXT(171$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 15 (Write waste fourth week)
;
171$          WRITE,         Staples Output,RECORDSET(Total waste fourth week):
                             fourthweekwaste:NEXT(172$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 16 (Write waste fifth week)
;
172$          WRITE,         Staples Output,RECORDSET(Total waste fifth week):
                             firstweekwaste:NEXT(187$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 17 (Write Total Waste from a previously frozen package)
;
187$          WRITE,         Staples Output,RECORDSET(Total waste from previously freezed packages):
                             totalwastefromfrozenbottle:NEXT(188$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 18 (Number of packages goes into freezer)
;
188$          WRITE,         Staples Output,RECORDSET(Number of packs to freezer):
                             bottlesgoingfreezer:NEXT(189$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 19 (Number of opened packages goes into freezer)
;
189$          WRITE,         Staples Output,RECORDSET(Number of previously opened packs to freezer):
                             halfbottlesgoingfreezer:NEXT(190$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 20 (Number of packages goes out of freezer)
;
190$          WRITE,         Staples Output,RECORDSET(Number of packs out of the freezer):
                             packagesoutoffreezer:NEXT(234$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 27 (Average time in freezer)
;
234$          WRITE,         Staples Output,RECORDSET(Average time in Freezer):
                             avgtimeinfreezer:NEXT(235$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 28 (Average time in fridge)
;
235$          WRITE,         Staples Output,RECORDSET(Average time in Fridge):
                             avgtimeinfridge:NEXT(236$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 29 (Active days of freezer)
;
236$          WRITE,         Staples Output,RECORDSET(Number of days the freezer is in use):
                             activedaysfreezer:NEXT(237$);


;
;
;     Model statements for module:  AdvancedProcess.ReadWrite 30 (Active days of fridge)
;
237$          WRITE,         Staples Output,RECORDSET(Number of days the fridge is in use):
                             activedaysfridge:NEXT(57$);


;
;
;     Model statements for module:  BasicProcess.Dispose 13 (Dispose 13)
;
57$           ASSIGN:        Dispose 13.NumberOut=Dispose 13.NumberOut + 1;
670$          DISPOSE:       Yes;


;
;
;     Model statements for module:  AdvancedProcess.File 2 (Staples Output)
;

;
;
;     Model statements for module:  BasicProcess.Create 11 (Create 11)
;

672$          CREATE,        1,DaysToBaseTime(0.0),Entity 1:DaysToBaseTime(1):NEXT(673$);

673$          ASSIGN:        Create 11.NumberOut=Create 11.NumberOut + 1:NEXT(64$);


;
;
;     Model statements for module:  BasicProcess.Dispose 14 (Dispose 14)
;
64$           ASSIGN:        Dispose 14.NumberOut=Dispose 14.NumberOut + 1;
676$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Create 13 (Create 13)
;

677$          CREATE,        1,HoursToBaseTime(0.0),Entity 1:HoursToBaseTime(EXPO(1)),1:NEXT(678$);

678$          ASSIGN:        Create 13.NumberOut=Create 13.NumberOut + 1:NEXT(77$);


;
;
;     Model statements for module:  BasicProcess.Decide 24 (Freezing on or off)
;
77$           BRANCH,        1:
                             If,freezeit==1,681$,Yes:
                             Else,682$,Yes;
681$          ASSIGN:        Freezing on or off.NumberOut True=Freezing on or off.NumberOut True + 1:NEXT(76$);

682$          ASSIGN:        Freezing on or off.NumberOut False=Freezing on or off.NumberOut False + 1:NEXT(78$);


;
;
;     Model statements for module:  BasicProcess.Assign 46 (Freezing on)
;
76$           ASSIGN:        freezeprobability=freezingprobability:NEXT(85$);


;
;
;     Model statements for module:  BasicProcess.Decide 27 (Checking fridge to freeze item on off)
;
85$           BRANCH,        1:
                             If,checkfridge==1,683$,Yes:
                             Else,684$,Yes;
683$          ASSIGN:        Checking fridge to freeze item on off.NumberOut True=
                             Checking fridge to freeze item on off.NumberOut True + 1:NEXT(86$);

684$          ASSIGN:        Checking fridge to freeze item on off.NumberOut False=
                             Checking fridge to freeze item on off.NumberOut False + 1:NEXT(87$);


;
;
;     Model statements for module:  BasicProcess.Assign 53 (Fridge Checking Variables)
;
86$           ASSIGN:        checktofreeze=1:NEXT(65$);


;
;
;     Model statements for module:  BasicProcess.Dispose 15 (Dispose 15)
;
65$           ASSIGN:        Dispose 15.NumberOut=Dispose 15.NumberOut + 1;
685$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Assign 54 (checking off)
;
87$           ASSIGN:        checktofreeze=0:NEXT(65$);


;
;
;     Model statements for module:  BasicProcess.Assign 47 (Freezing off)
;
78$           ASSIGN:        freezeprobability=0:
                             checktofreeze=0:NEXT(65$);


;
;
;     Model statements for module:  BasicProcess.Create 16 (Check if items in the fridge close to expiration date)
;

686$          CREATE,        checktofreeze,DaysToBaseTime(0.0),Entity 1:DaysToBaseTime(checkinginterval):NEXT(687$);

687$          ASSIGN:        Check if items in the fridge close to expiration date.NumberOut=
                             Check if items in the fridge close to expiration date.NumberOut + 1:NEXT(210$);


;
;
;     Model statements for module:  AdvancedProcess.Search 1 (Search 1)
;
210$          SEARCH,        Unopened packages.Queue,1,NQ:ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == 0;
690$          BRANCH,        1:
                             If,J<>0,691$,Yes:
                             Else,692$,Yes;
691$          DELAY:         0.0,,VA:NEXT(191$);

692$          DELAY:         0.0,,VA:NEXT(79$);


;
;
;     Model statements for module:  BasicProcess.Decide 67 (Freezing probability for items that are about to expire)
;
191$          BRANCH,        1:
                             With,(freezeprobexp)/100,693$,Yes:
                             Else,694$,Yes;
693$          ASSIGN:        Freezing probability for items that are about to expire.NumberOut True=
                             Freezing probability for items that are about to expire.NumberOut True + 1:NEXT(80$);

694$          ASSIGN:        Freezing probability for items that are about to expire.NumberOut False=
                             Freezing probability for items that are about to expire.NumberOut False + 1:NEXT(79$);


;
;
;     Model statements for module:  AdvancedProcess.Search and Remove 2 (Search and Remove 2)
;
80$           SEARCH,        Unopened packages.Queue,1,NQ(Unopened packages.Queue):
                             ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == 0;
715$          BRANCH,        1:
                             If,J<>0,697$,Yes:
                             Else,696$,Yes;
697$          REMOVE:        J,Unopened packages.Queue,211$;
699$          ASSIGN:        Search and Remove 2.NumberRemoved=Search and Remove 2.NumberRemoved + 1:NEXT(80$);

696$          DELAY:         0.0,,VA:NEXT(79$);


;
;
;     Model statements for module:  BasicProcess.Assign 121 (assign the date it is going to freezer)
;
211$          ASSIGN:        buydate=ANINT(DaysToBaseTime(TNOW)):NEXT(223$);


;
;
;     Model statements for module:  BasicProcess.Dispose 18 (Dispose 18)
;
79$           ASSIGN:        Dispose 18.NumberOut=Dispose 18.NumberOut + 1;
716$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Create 17 (Check the open package)
;

717$          CREATE,        checktofreeze,DaysToBaseTime(0.0),Entity 1:DaysToBaseTime(checkinginterval):NEXT(718$);

718$          ASSIGN:        Check the open package.NumberOut=Check the open package.NumberOut + 1:NEXT(224$);


;
;
;     Model statements for module:  BasicProcess.Decide 80 (Decide 80)
;
224$          BRANCH,        1:
                             If,currentopenamount>0,721$,Yes:
                             Else,722$,Yes;
721$          ASSIGN:        Decide 80.NumberOut True=Decide 80.NumberOut True + 1:NEXT(81$);

722$          ASSIGN:        Decide 80.NumberOut False=Decide 80.NumberOut False + 1:NEXT(83$);


;
;
;     Model statements for module:  BasicProcess.Decide 26 (Decide 26)
;
81$           BRANCH,        1:
                             If,
                             ANINT(DaysToBaseTime(TNOW))-currentopenpackshelflife-currentopenpackbuydate == 0 && thawed==0  && currentamount>= minfreeze,
                             192$,Yes:
                             If,
                             ANINT(DaysToBaseTime(TNOW))-currentopenpackopendate==onceopen && thawed==0 && currentamount>= minfreeze,
                             192$,Yes:
                             Else,83$,Yes;

;
;
;     Model statements for module:  BasicProcess.Dispose 19 (Dispose 19)
;
83$           ASSIGN:        Dispose 19.NumberOut=Dispose 19.NumberOut + 1;
725$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Decide 68 (Freezing probability for open pack items that are about to expire)
;
192$          BRANCH,        1:
                             With,(freezeprobexp)/100,726$,Yes:
                             Else,727$,Yes;
726$          ASSIGN:        Freezing probability for open pack items that are about to expire.NumberOut True=
                             Freezing probability for open pack items that are about to expire.NumberOut True + 1:NEXT(82$);

727$          ASSIGN:        Freezing probability for open pack items that are about to expire.NumberOut False=
                             Freezing probability for open pack items that are about to expire.NumberOut False + 1:NEXT(83$);


;
;
;     Model statements for module:  BasicProcess.Assign 51 (assign packsize freezing date shelf life and calculate half bottles going to freezer)
;
82$           ASSIGN:        packsize=currentopenamount:
                             currentopenamount=0:
                             buydate=ANINT(DaysToBaseTime(TNOW)):
                             ShelfLife=currentopenpackshelflife:
                             halfbottlesgoingfreezer=halfbottlesgoingfreezer+1:NEXT(223$);


;
;
;     Model statements for module:  BasicProcess.Create 19 (Throw away the items stayed for too long in the freezer)
;

728$          CREATE,        1,DaysToBaseTime(0.0),Entity 1:DaysToBaseTime(1):NEXT(729$);

729$          ASSIGN:        Throw away the items stayed for too long in the freezer.NumberOut=
                             Throw away the items stayed for too long in the freezer.NumberOut + 1:NEXT(90$);


;
;
;     Model statements for module:  AdvancedProcess.Search and Remove 3 (Search and Remove 3)
;
90$           SEARCH,        Unopened packages in freezer.Queue,1,NQ(Unopened packages in freezer.Queue):
                             ANINT(DaysToBaseTime(TNOW))-buydate == 180;
752$          BRANCH,        1:
                             If,J<>0,734$,Yes:
                             Else,733$,Yes;
734$          REMOVE:        J,Unopened packages in freezer.Queue,91$;
736$          ASSIGN:        Search and Remove 3.NumberRemoved=Search and Remove 3.NumberRemoved + 1:NEXT(90$);

733$          DELAY:         0.0,,VA:NEXT(89$);


;
;
;     Model statements for module:  BasicProcess.Assign 57 (Update Waste)
;
91$           ASSIGN:        totalwasteexpdate=totalwasteexpdate+packsize:
                             totalwastefreezer=totalwastefreezer+packsize:
                             currentamount=currentamount-packsize:NEXT(89$);


;
;
;     Model statements for module:  BasicProcess.Dispose 21 (Dispose 21)
;
89$           ASSIGN:        Dispose 21.NumberOut=Dispose 21.NumberOut + 1;
753$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Create 21 (Special Occasions)
;

754$          CREATE,        opportunitynumberspecialoccasion,DaysToBaseTime(0.2),Entity 1:DaysToBaseTime(occasioninterval)
                             :NEXT(755$);

755$          ASSIGN:        Special Occasions.NumberOut=Special Occasions.NumberOut + 1:NEXT(95$);


;
;
;     Model statements for module:  BasicProcess.Assign 59 (Consumption amount for special occasions)
;
95$           ASSIGN:        consume=ANINT(consumptionspecial):NEXT(280$);


;
;
;     Model statements for module:  BasicProcess.Decide 153 (Decide 153)
;
280$          BRANCH,        1:
                             If,consume>0,758$,Yes:
                             Else,759$,Yes;
758$          ASSIGN:        Decide 153.NumberOut True=Decide 153.NumberOut True + 1:NEXT(114$);

759$          ASSIGN:        Decide 153.NumberOut False=Decide 153.NumberOut False + 1:NEXT(95$);


;
;
;     Model statements for module:  BasicProcess.Decide 45 (Check if current amount sufficient for special occasion cooking)
;
114$          BRANCH,        1:
                             If,currentamount>=consume,760$,Yes:
                             Else,761$,Yes;
760$          ASSIGN:        Check if current amount sufficient for special occasion cooking.NumberOut True=
                             Check if current amount sufficient for special occasion cooking.NumberOut True + 1:NEXT(49$);

761$          ASSIGN:        Check if current amount sufficient for special occasion cooking.NumberOut False=
                             Check if current amount sufficient for special occasion cooking.NumberOut False + 1:NEXT(120$);


;
;
;     Model statements for module:  BasicProcess.Assign 80 (Calculate how many packages are needed for special occasion)
;
120$          ASSIGN:        missingamount=consume-currentamount:NEXT(131$);


;
;
;     Model statements for module:  BasicProcess.Decide 52 (Decide 52)
;
131$          BRANCH,        1:
                             If,(missingamount/size)-ANINT(missingamount/size) >= 0.5,762$,Yes:
                             Else,763$,Yes;
762$          ASSIGN:        Decide 52.NumberOut True=Decide 52.NumberOut True + 1:NEXT(130$);

763$          ASSIGN:        Decide 52.NumberOut False=Decide 52.NumberOut False + 1:NEXT(132$);


;
;
;     Model statements for module:  BasicProcess.Assign 86 (Calculate how many packages are needed for the special occasion)
;
130$          ASSIGN:        packagesneeded=ANINT(missingamount/size):NEXT(122$);


;
;
;     Model statements for module:  BasicProcess.Assign 81 (Assign 81)
;
122$          ASSIGN:        special=1:NEXT(121$);


;
;
;     Model statements for module:  AdvancedTransfer.Route 5 (Go to a top up shop and purchase the missing amount)
;
121$          ROUTE:         0.000000000000000,Station 1;


;
;
;     Model statements for module:  BasicProcess.Assign 87 (Calculate how many packages are needed for the special occasion 2)
;
132$          ASSIGN:        packagesneeded=ANINT(missingamount/size)+1:NEXT(122$);


;
;
;     Model statements for module:  BasicProcess.Create 22 (Opportunity to Cook)
;

764$          CREATE,        opportunitynumbercooking,DaysToBaseTime(0.2),cooking:DaysToBaseTime(opportunitycooking):NEXT(765$);

765$          ASSIGN:        Opportunity to Cook.NumberOut=Opportunity to Cook.NumberOut + 1:NEXT(97$);


;
;
;     Model statements for module:  BasicProcess.Assign 60 (Consumption amount for cooking)
;
97$           ASSIGN:        consume=ANINT(consumptioncooking):NEXT(279$);


;
;
;     Model statements for module:  BasicProcess.Decide 152 (Decide 152)
;
279$          BRANCH,        1:
                             If,consume>0,768$,Yes:
                             Else,769$,Yes;
768$          ASSIGN:        Decide 152.NumberOut True=Decide 152.NumberOut True + 1:NEXT(265$);

769$          ASSIGN:        Decide 152.NumberOut False=Decide 152.NumberOut False + 1:NEXT(97$);


;
;
;     Model statements for module:  BasicProcess.Decide 138 (Increase consumption probability unopened cooking)
;
265$          BRANCH,        1:
                             If,notemptyfridgeincreasecooking==1,267$,Yes:
                             If,unopenedincreasecooking==1,264$,Yes:
                             If,openedincreasecooking==1,262$,Yes:
                             Else,96$,Yes;

;
;
;     Model statements for module:  BasicProcess.Decide 33 (Probability of Consumption for Cooking)
;
96$           BRANCH,        1:
                             With,(probabilitycooking)/100,772$,Yes:
                             Else,773$,Yes;
772$          ASSIGN:        Probability of Consumption for Cooking.NumberOut True=
                             Probability of Consumption for Cooking.NumberOut True + 1:NEXT(271$);

773$          ASSIGN:        Probability of Consumption for Cooking.NumberOut False=
                             Probability of Consumption for Cooking.NumberOut False + 1:NEXT(3$);


;
;
;     Model statements for module:  BasicProcess.Decide 143 (Check if current amount sufficient for cooking)
;
271$          BRANCH,        1:
                             If,currentamount>=consume,774$,Yes:
                             Else,775$,Yes;
774$          ASSIGN:        Check if current amount sufficient for cooking.NumberOut True=
                             Check if current amount sufficient for cooking.NumberOut True + 1:NEXT(275$);

775$          ASSIGN:        Check if current amount sufficient for cooking.NumberOut False=
                             Check if current amount sufficient for cooking.NumberOut False + 1:NEXT(272$);


;
;
;     Model statements for module:  BasicProcess.Decide 144 (What the household will do)
;
272$          BRANCH,        1:
                             With,(probdontcook)/100,274$,Yes:
                             With,(probcookavailable)/100,49$,Yes:
                             Else,273$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 143 (label for cooking)
;
273$          ASSIGN:        forcooking=1:NEXT(49$);


;
;
;     Model statements for module:  BasicProcess.Assign 144 (calculate the requirement not fulfilled)
;
274$          ASSIGN:        reqnotfulfilledmissingamount=reqnotfulfilledmissingamount+consume:NEXT(3$);


;
;
;     Model statements for module:  BasicProcess.Decide 140 (Check if fridge is empty or not cooking)
;
267$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue) >0  || currentopenamount>0,778$,Yes:
                             Else,779$,Yes;
778$          ASSIGN:        Check if fridge is empty or not cooking.NumberOut True=
                             Check if fridge is empty or not cooking.NumberOut True + 1:NEXT(266$);

779$          ASSIGN:        Check if fridge is empty or not cooking.NumberOut False=
                             Check if fridge is empty or not cooking.NumberOut False + 1:NEXT(96$);


;
;
;     Model statements for module:  BasicProcess.Decide 139 (Probability of Consumption cooking increase when frisge is not empty)
;
266$          BRANCH,        1:
                             With,(probabilitycooking+notemptyfridgeincreasecookingprob)/100,780$,Yes:
                             Else,781$,Yes;
780$          ASSIGN:        Probability of Consumption cooking increase when frisge is not empty.NumberOut True=
                             Probability of Consumption cooking increase when frisge is not empty.NumberOut True + 1:NEXT(271$);

781$          ASSIGN:        Probability of Consumption cooking increase when frisge is not empty.NumberOut False=
                             Probability of Consumption cooking increase when frisge is not empty.NumberOut False + 1:NEXT(3$);


;
;
;     Model statements for module:  BasicProcess.Decide 137 (Check if there are unopened packages in the fridge cooking)
;
264$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue)  >  0,782$,Yes:
                             Else,783$,Yes;
782$          ASSIGN:        Check if there are unopened packages in the fridge cooking.NumberOut True=
                             Check if there are unopened packages in the fridge cooking.NumberOut True + 1:NEXT(263$);

783$          ASSIGN:        Check if there are unopened packages in the fridge cooking.NumberOut False=
                             Check if there are unopened packages in the fridge cooking.NumberOut False + 1:NEXT(96$);


;
;
;     Model statements for module:  BasicProcess.Decide 136 (Probability of Consumption cooking increased when there are unopened packages in the fridge)
;
263$          BRANCH,        1:
                             With,(probabilitycooking+unopenedincreasecookingprob)/100,784$,Yes:
                             Else,785$,Yes;
784$          ASSIGN:        
                             Probability of Consumption cooking increased when there are unopened packages in the fridge.NumberOut True=
                             Probability of Consumption cooking increased when there are unopened packages in the fridge.NumberOut True + 1
                             :NEXT(271$);

785$          ASSIGN:        
                             Probability of Consumption cooking increased when there are unopened packages in the fridge.NumberOut False=
                             Probability of Consumption cooking increased when there are unopened packages in the fridge.NumberOut False + 1
                             :NEXT(3$);


;
;
;     Model statements for module:  BasicProcess.Decide 135 (Check if there are opened packages in the fridge cooking)
;
262$          BRANCH,        1:
                             If,currentopenamount>consume,786$,Yes:
                             Else,787$,Yes;
786$          ASSIGN:        Check if there are opened packages in the fridge cooking.NumberOut True=
                             Check if there are opened packages in the fridge cooking.NumberOut True + 1:NEXT(268$);

787$          ASSIGN:        Check if there are opened packages in the fridge cooking.NumberOut False=
                             Check if there are opened packages in the fridge cooking.NumberOut False + 1:NEXT(96$);


;
;
;     Model statements for module:  BasicProcess.Decide 141 (Probability of Consumption cooking increased when there are opened packages in the fridge)
;
268$          BRANCH,        1:
                             With,(probabilitycooking+openedincreasecookingprob)/100,788$,Yes:
                             Else,789$,Yes;
788$          ASSIGN:        
                             Probability of Consumption cooking increased when there are opened packages in the fridge.NumberOut True=
                             Probability of Consumption cooking increased when there are opened packages in the fridge.NumberOut True + 1
                             :NEXT(271$);

789$          ASSIGN:        
                             Probability of Consumption cooking increased when there are opened packages in the fridge.NumberOut False=
                             Probability of Consumption cooking increased when there are opened packages in the fridge.NumberOut False + 1
                             :NEXT(3$);


;
;
;     Model statements for module:  AdvancedTransfer.Station 1
;

106$          STATION,       Station 1;
792$          DELAY:         0.0,,VA:NEXT(110$);


;
;
;     Model statements for module:  BasicProcess.Assign 73 (Change picture for purchasing missing amount for recipes)
;
110$          ASSIGN:        Picture=Picture.Box:NEXT(108$);


;
;
;     Model statements for module:  BasicProcess.Assign 72 (Assign package size for missing amount top up shop visit)
;
108$          ASSIGN:        packsize=size:NEXT(197$);


;
;
;     Model statements for module:  BasicProcess.Assign 116 (Update number of topupshop visits 2)
;
197$          ASSIGN:        topupshopvisit=topupshopvisit+1:NEXT(109$);


;
;
;     Model statements for module:  BasicProcess.Separate 8 (Number of packages purchased for missing amount)
;
109$          DUPLICATE,     100 - 50:
                             packagesneeded-1,795$,50:NEXT(794$);

794$          ASSIGN:        Number of packages purchased for missing amount.NumberOut Orig=
                             Number of packages purchased for missing amount.NumberOut Orig + 1:NEXT(202$);

795$          ASSIGN:        Number of packages purchased for missing amount.NumberOut Dup=
                             Number of packages purchased for missing amount.NumberOut Dup + 1:NEXT(202$);


;
;
;     Model statements for module:  BasicProcess.Assign 119 (Calculate the amount purchased from topup shop visits 2)
;
202$          ASSIGN:        totaltopupshoppurchase=totaltopupshoppurchase+packsize:NEXT(107$);


;
;
;     Model statements for module:  BasicProcess.Assign 71 (Assign the purchase date and shelflife and update current amount for missing amount purchase)
;
107$          ASSIGN:        buydate=ANINT(DaysToBaseTime(TNOW)):
                             ShelfLife=ANINT(itemshelflife):
                             currentamount=currentamount+packsize:
                             totalpurchased=totalpurchased+packsize:
                             numberofpackagespurchased=numberofpackagespurchased+1:
                             opendate=99999999:NEXT(115$);


;
;
;     Model statements for module:  BasicProcess.Decide 47 (check if cooking or special occasion)
;
115$          BRANCH,        1:
                             If,special==1,796$,Yes:
                             Else,797$,Yes;
796$          ASSIGN:        check if cooking or special occasion.NumberOut True=
                             check if cooking or special occasion.NumberOut True + 1:NEXT(117$);

797$          ASSIGN:        check if cooking or special occasion.NumberOut False=
                             check if cooking or special occasion.NumberOut False + 1:NEXT(111$);


;
;
;     Model statements for module:  BasicProcess.Decide 49 (Canceling probability)
;
117$          BRANCH,        1:
                             With,(probabilityspecialcancel)/100,798$,Yes:
                             Else,799$,Yes;
798$          ASSIGN:        Canceling probability.NumberOut True=Canceling probability.NumberOut True + 1:NEXT(116$);

799$          ASSIGN:        Canceling probability.NumberOut False=Canceling probability.NumberOut False + 1:NEXT(126$);


;
;
;     Model statements for module:  BasicProcess.Decide 48 (Probability of freezing)
;
116$          BRANCH,        1:
                             With,(freezethem)/100,800$,Yes:
                             Else,801$,Yes;
800$          ASSIGN:        Probability of freezing.NumberOut True=Probability of freezing.NumberOut True + 1:NEXT(134$);

801$          ASSIGN:        Probability of freezing.NumberOut False=Probability of freezing.NumberOut False + 1:NEXT(111$);


;
;
;     Model statements for module:  BasicProcess.Decide 53 (Decide 53)
;
134$          BRANCH,        1:
                             If,freezeit==1,802$,Yes:
                             Else,803$,Yes;
802$          ASSIGN:        Decide 53.NumberOut True=Decide 53.NumberOut True + 1:NEXT(118$);

803$          ASSIGN:        Decide 53.NumberOut False=Decide 53.NumberOut False + 1:NEXT(111$);


;
;
;     Model statements for module:  AdvancedTransfer.Route 4 (store it in the freezer)
;
118$          ROUTE:         0.000000000000000,Freezer;


;
;
;     Model statements for module:  AdvancedTransfer.Route 3 (store it in the fridge or pantry)
;
111$          ROUTE:         0.000000000000000,Fridge;


;
;
;     Model statements for module:  BasicProcess.Separate 12 (Separate 12)
;
126$          DUPLICATE,     100 - 50:
                             1,806$,50:NEXT(805$);

805$          ASSIGN:        Separate 12.NumberOut Orig=Separate 12.NumberOut Orig + 1:NEXT(111$);

806$          ASSIGN:        Separate 12.NumberOut Dup=Separate 12.NumberOut Dup + 1:NEXT(127$);


;
;
;     Model statements for module:  AdvancedTransfer.Route 9 (Once it is purchased continue cooking for special occasion)
;
127$          ROUTE:         0.000000000000000,continuespecialcooking;


;
;
;     Model statements for module:  AdvancedTransfer.Station 2
;

112$          STATION,       Fridge;
809$          DELAY:         0.0,,VA:NEXT(11$);


;
;
;     Model statements for module:  AdvancedTransfer.Station 3
;

113$          STATION,       continuecooking;
812$          DELAY:         0.0,,VA:NEXT(8$);


;
;
;     Model statements for module:  AdvancedTransfer.Station 4
;

119$          STATION,       Freezer;
815$          DELAY:         0.0,,VA:NEXT(223$);


;
;
;     Model statements for module:  AdvancedTransfer.Station 5
;

133$          STATION,       continuespecialcooking;
818$          DELAY:         0.0,,VA:NEXT(49$);


;
;
;     Model statements for module:  BasicProcess.Create 23 (Household MainShop Shopping Patterns Random)
;

819$          CREATE,        mainrandom,DaysToBaseTime(0.1),Entity 1:DaysToBaseTime(ANINT(UNIF( 3, 5 ))):NEXT(820$);

820$          ASSIGN:        Household MainShop Shopping Patterns Random.NumberOut=
                             Household MainShop Shopping Patterns Random.NumberOut + 1:NEXT(135$);


;
;
;     Model statements for module:  BasicProcess.Assign 88 (Assign shopping day)
;
135$          ASSIGN:        shop=CalDayOfWeek(TNOW):NEXT(136$);


;
;
;     Model statements for module:  BasicProcess.Assign 89 (Show shopping day for random shopping)
;
136$          ASSIGN:        mainshopday=shop:NEXT(43$);


;
;
;     Model statements for module:  BasicProcess.Create 24 (Daily expired item check)
;

823$          CREATE,        1,DaysToBaseTime(0.0),Entity 1:DaysToBaseTime(1):NEXT(824$);

824$          ASSIGN:        Daily expired item check.NumberOut=Daily expired item check.NumberOut + 1:NEXT(137$);


;
;
;     Model statements for module:  AdvancedProcess.Search and Remove 8 (Search the fridge and remove expired products)
;
137$          SEARCH,        Unopened packages.Queue,1,NQ(Unopened packages.Queue):
                             ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == 0  || (ANINT(DaysToBaseTime(TNOW))-opendate) >= onceopen;
847$          BRANCH,        1:
                             If,J<>0,829$,Yes:
                             Else,828$,Yes;
829$          REMOVE:        J,Unopened packages.Queue,314$;
831$          ASSIGN:        Search the fridge and remove expired products.NumberRemoved=
                             Search the fridge and remove expired products.NumberRemoved + 1:NEXT(137$);

828$          DELAY:         0.0,,VA:NEXT(138$);


;
;
;     Model statements for module:  BasicProcess.Decide 161 (Decide 161)
;
314$          BRANCH,        1:
                             If,usetobeopened==1  &&  (ANINT(DaysToBaseTime(TNOW))-opendate) >= onceopen,848$,Yes:
                             Else,849$,Yes;
848$          ASSIGN:        Decide 161.NumberOut True=Decide 161.NumberOut True + 1:NEXT(147$);

849$          ASSIGN:        Decide 161.NumberOut False=Decide 161.NumberOut False + 1:NEXT(315$);


;
;
;     Model statements for module:  BasicProcess.Assign 95 (Waste calculation previously opened package)
;
147$          ASSIGN:        totalwasteexpdate=totalwasteexpdate+packsize:NEXT(142$);


;
;
;     Model statements for module:  BasicProcess.Assign 92 (Update total waste amount special occasion)
;
142$          ASSIGN:        totalwaste=totalwaste+packsize:
                             currentamount=currentamount-packsize:NEXT(143$);


;
;
;     Model statements for module:  BasicProcess.Dispose 26 (throw the expired packages)
;
143$          ASSIGN:        throw the expired packages.NumberOut=throw the expired packages.NumberOut + 1;
850$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Assign 164 (Waste calculation)
;
315$          ASSIGN:        totalwasteexpdate=totalwasteexpdate+packsize:NEXT(142$);


;
;
;     Model statements for module:  AdvancedProcess.Search and Remove 9 (Search the freezer and remove expired products)
;
138$          SEARCH,        Unopened packages in freezer.Queue,1,NQ(Unopened packages in freezer.Queue):
                             ANINT(DaysToBaseTime(TNOW))-ShelfLife-buydate == 0;
871$          BRANCH,        1:
                             If,J<>0,853$,Yes:
                             Else,852$,Yes;
853$          REMOVE:        J,Unopened packages in freezer.Queue,148$;
855$          ASSIGN:        Search the freezer and remove expired products.NumberRemoved=
                             Search the freezer and remove expired products.NumberRemoved + 1:NEXT(138$);

852$          DELAY:         0.0,,VA:NEXT(139$);


;
;
;     Model statements for module:  BasicProcess.Assign 96 (Waste calculation 2)
;
148$          ASSIGN:        totalwastefromfreezer=totalwastefromfreezer+packsize:
                             packagesoutoffreezer=packagesoutoffreezer+1:NEXT(142$);


;
;
;     Model statements for module:  BasicProcess.Assign 90 (Current open package open date shelf life and exp date check before special occasion)
;
139$          ASSIGN:        opendate=currentopenpackopendate:
                             buydate=currentopenpackbuydate:
                             ShelfLife=currentopenpackshelflife:NEXT(185$);


;
;
;     Model statements for module:  BasicProcess.Decide 66 (Check if the current open bottle was frozen before)
;
185$          BRANCH,        1:
                             If,thawed==1,872$,Yes:
                             Else,873$,Yes;
872$          ASSIGN:        Check if the current open bottle was frozen before.NumberOut True=
                             Check if the current open bottle was frozen before.NumberOut True + 1:NEXT(208$);

873$          ASSIGN:        Check if the current open bottle was frozen before.NumberOut False=
                             Check if the current open bottle was frozen before.NumberOut False + 1:NEXT(140$);


;
;
;     Model statements for module:  BasicProcess.Decide 70 (Check if the thawed open pack expired in the fridge or pantry)
;
208$          BRANCH,        1:
                             If,(ANINT(DaysToBaseTime(TNOW))-opendate) >= onceopen && currentopenamount>0,186$,Yes:
                             Else,144$,Yes;

;
;
;     Model statements for module:  BasicProcess.Dispose 27 (Dispose 27)
;
144$          ASSIGN:        Dispose 27.NumberOut=Dispose 27.NumberOut + 1;
876$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Assign 111 (Calculate waste from thawed shelf life)
;
186$          ASSIGN:        totalwastefromfrozenbottle=totalwastefromfrozenbottle+currentopenamount:NEXT(141$);


;
;
;     Model statements for module:  BasicProcess.Assign 91 (Calculate total waste and throw the packages that are expired)
;
141$          ASSIGN:        totalwaste=totalwaste+currentopenamount:
                             currentamount=currentamount-currentopenamount:
                             totalwastefromfridge=totalwastefromfridge+currentopenamount:
                             currentopenamount=0:NEXT(144$);


;
;
;     Model statements for module:  BasicProcess.Decide 54 (Check if the open pack expired in the fridge or pantry)
;
140$          BRANCH,        1:
                             If,(ANINT(DaysToBaseTime(TNOW))-buydate)  >=  ShelfLife && currentopenamount>0,149$,Yes:
                             If,(ANINT(DaysToBaseTime(TNOW))-opendate) >= onceopen && currentopenamount>0,150$,Yes:
                             Else,144$,Yes;

;
;
;     Model statements for module:  BasicProcess.Assign 98 (Waste from expiration date calculation)
;
149$          ASSIGN:        totalwasteexpdate=totalwasteexpdate+currentopenamount:NEXT(141$);


;
;
;     Model statements for module:  BasicProcess.Assign 99 (Waste from open shelf life calculation)
;
150$          ASSIGN:        totalwasteopenshelflife=totalwasteopenshelflife+currentopenamount:NEXT(141$);


;
;
;     Model statements for module:  BasicProcess.Create 25 (Calculate weekly waste)
;

879$          CREATE,        1,DaysToBaseTime(8),Entity 1:DaysToBaseTime(EXPO(1)),1:NEXT(880$);

880$          ASSIGN:        Calculate weekly waste.NumberOut=Calculate weekly waste.NumberOut + 1:NEXT(158$);


;
;
;     Model statements for module:  BasicProcess.Assign 103 (First weeks waste)
;
158$          ASSIGN:        firstweekwaste=totalwaste:NEXT(164$);


;
;
;     Model statements for module:  AdvancedProcess.Delay 1 (Wait one week)
;
164$          DELAY:         7,,Other:NEXT(159$);


;
;
;     Model statements for module:  BasicProcess.Assign 104 (Second weeks waste)
;
159$          ASSIGN:        secondweekwaste=totalwaste-firstweekwaste:NEXT(165$);


;
;
;     Model statements for module:  AdvancedProcess.Delay 2 (Wait one week 2)
;
165$          DELAY:         7,,Other:NEXT(160$);


;
;
;     Model statements for module:  BasicProcess.Assign 105 (Third weeks waste)
;
160$          ASSIGN:        thirdweekwaste=totalwaste-firstweekwaste-secondweekwaste:NEXT(166$);


;
;
;     Model statements for module:  AdvancedProcess.Delay 3 (Wait one week 3)
;
166$          DELAY:         7,,Other:NEXT(161$);


;
;
;     Model statements for module:  BasicProcess.Assign 106 (Fourth weeks waste)
;
161$          ASSIGN:        fourthweekwaste=totalwaste-firstweekwaste-secondweekwaste-thirdweekwaste:NEXT(167$);


;
;
;     Model statements for module:  AdvancedProcess.Delay 4 (Wait one week 4)
;
167$          DELAY:         7,,Other:NEXT(162$);


;
;
;     Model statements for module:  BasicProcess.Assign 107 (Fifth weeks waste)
;
162$          ASSIGN:        fifthweekwaste=totalwaste-firstweekwaste-secondweekwaste-thirdweekwaste-fourthweekwaste:NEXT(163$);


;
;
;     Model statements for module:  BasicProcess.Dispose 28 (Dispose 28)
;
163$          ASSIGN:        Dispose 28.NumberOut=Dispose 28.NumberOut + 1;
883$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Create 28 (Opportunity to consume directly younger children)
;

884$          CREATE,        youngerchild,DaysToBaseTime(0.2),drinking:DaysToBaseTime(1):NEXT(885$);

885$          ASSIGN:        Opportunity to consume directly younger children.NumberOut=
                             Opportunity to consume directly younger children.NumberOut + 1:NEXT(250$);


;
;
;     Model statements for module:  BasicProcess.Decide 123 (Increase consumption probability unopened younger children)
;
250$          BRANCH,        1:
                             If,notemptyfridgeincrease==1,252$,Yes:
                             If,unopenedincrease==1,249$,Yes:
                             If,openedincrease==1,247$,Yes:
                             Else,246$,Yes;

;
;
;     Model statements for module:  BasicProcess.Decide 119 (Probability of Consumption younger children)
;
246$          BRANCH,        1:
                             With,(probabilityyounger)/100,890$,Yes:
                             Else,891$,Yes;
890$          ASSIGN:        Probability of Consumption younger children.NumberOut True=
                             Probability of Consumption younger children.NumberOut True + 1:NEXT(213$);

891$          ASSIGN:        Probability of Consumption younger children.NumberOut False=
                             Probability of Consumption younger children.NumberOut False + 1:NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Assign 124 (Consumption amount for younger children)
;
213$          ASSIGN:        consume=ANINT(consumptionyounger):NEXT(277$);


;
;
;     Model statements for module:  BasicProcess.Decide 150 (Decide 150)
;
277$          BRANCH,        1:
                             If,consume>0,892$,Yes:
                             Else,893$,Yes;
892$          ASSIGN:        Decide 150.NumberOut True=Decide 150.NumberOut True + 1:NEXT(98$);

893$          ASSIGN:        Decide 150.NumberOut False=Decide 150.NumberOut False + 1:NEXT(213$);


;
;
;     Model statements for module:  BasicProcess.Decide 125 (Check if fridge is empty or not younger children)
;
252$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue) >0  || currentopenamount>0,894$,Yes:
                             Else,895$,Yes;
894$          ASSIGN:        Check if fridge is empty or not younger children.NumberOut True=
                             Check if fridge is empty or not younger children.NumberOut True + 1:NEXT(251$);

895$          ASSIGN:        Check if fridge is empty or not younger children.NumberOut False=
                             Check if fridge is empty or not younger children.NumberOut False + 1:NEXT(246$);


;
;
;     Model statements for module:  BasicProcess.Decide 124 (Probability of Consumption younger children increase when frisge is not empty)
;
251$          BRANCH,        1:
                             With,(probabilityyounger+notemptyfridgeincreaseprob)/100,896$,Yes:
                             Else,897$,Yes;
896$          ASSIGN:        Probability of Consumption younger children increase when frisge is not empty.NumberOut True=
                             Probability of Consumption younger children increase when frisge is not empty.NumberOut True + 1
                             :NEXT(213$);

897$          ASSIGN:        Probability of Consumption younger children increase when frisge is not empty.NumberOut False=
                             Probability of Consumption younger children increase when frisge is not empty.NumberOut False + 1
                             :NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Decide 122 (Check if there are unopened packages in the fridge younger children)
;
249$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue)  >  0,898$,Yes:
                             Else,899$,Yes;
898$          ASSIGN:        Check if there are unopened packages in the fridge younger children.NumberOut True=
                             Check if there are unopened packages in the fridge younger children.NumberOut True + 1:NEXT(248$);

899$          ASSIGN:        Check if there are unopened packages in the fridge younger children.NumberOut False=
                             Check if there are unopened packages in the fridge younger children.NumberOut False + 1:NEXT(246$);


;
;
;     Model statements for module:  BasicProcess.Decide 121 (Probability of Consumption younger children increased when there are unopened packages in the fridge)
;
248$          BRANCH,        1:
                             With,(probabilityyounger+unopenedincreaseprob)/100,900$,Yes:
                             Else,901$,Yes;
900$          ASSIGN:        
                             Probability of Consumption younger children increased when there are unopened packages in the fridge.NumberOut True=
                             Probability of Consumption younger children increased when there are unopened packages in the fridge.NumberOut True + 1
                             :NEXT(213$);

901$          ASSIGN:        
                             Probability of Consumption younger children increased when there are unopened packages in the fridge.NumberOut False=
                             Probability of Consumption younger children increased when there are unopened packages in the fridge.NumberOut False + 1
                             :NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Decide 120 (Check if there are opened packages in the fridge younger children)
;
247$          BRANCH,        1:
                             If,currentopenamount>0,902$,Yes:
                             Else,903$,Yes;
902$          ASSIGN:        Check if there are opened packages in the fridge younger children.NumberOut True=
                             Check if there are opened packages in the fridge younger children.NumberOut True + 1:NEXT(253$);

903$          ASSIGN:        Check if there are opened packages in the fridge younger children.NumberOut False=
                             Check if there are opened packages in the fridge younger children.NumberOut False + 1:NEXT(246$);


;
;
;     Model statements for module:  BasicProcess.Decide 126 (Probability of Consumption younger children increased when there are opened packages in the fridge)
;
253$          BRANCH,        1:
                             With,(probabilityyounger+openedincreaseprob)/100,904$,Yes:
                             Else,905$,Yes;
904$          ASSIGN:        
                             Probability of Consumption younger children increased when there are opened packages in the fridge.NumberOut True=
                             Probability of Consumption younger children increased when there are opened packages in the fridge.NumberOut True + 1
                             :NEXT(213$);

905$          ASSIGN:        
                             Probability of Consumption younger children increased when there are opened packages in the fridge.NumberOut False=
                             Probability of Consumption younger children increased when there are opened packages in the fridge.NumberOut False + 1
                             :NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Create 29 (Opportunity to consume directly older children)
;

906$          CREATE,        olderchild,DaysToBaseTime(0.2),drinking:DaysToBaseTime(1):NEXT(907$);

907$          ASSIGN:        Opportunity to consume directly older children.NumberOut=
                             Opportunity to consume directly older children.NumberOut + 1:NEXT(258$);


;
;
;     Model statements for module:  BasicProcess.Decide 131 (Increase consumption probability unopened older children)
;
258$          BRANCH,        1:
                             If,notemptyfridgeincrease==1,260$,Yes:
                             If,unopenedincrease==1,257$,Yes:
                             If,openedincrease==1,255$,Yes:
                             Else,254$,Yes;

;
;
;     Model statements for module:  BasicProcess.Decide 127 (Probability of Consumption older children)
;
254$          BRANCH,        1:
                             With,(probabilityolder)/100,912$,Yes:
                             Else,913$,Yes;
912$          ASSIGN:        Probability of Consumption older children.NumberOut True=
                             Probability of Consumption older children.NumberOut True + 1:NEXT(214$);

913$          ASSIGN:        Probability of Consumption older children.NumberOut False=
                             Probability of Consumption older children.NumberOut False + 1:NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Assign 125 (Consumption amount for older children)
;
214$          ASSIGN:        consume=ANINT(consumptionolder):NEXT(278$);


;
;
;     Model statements for module:  BasicProcess.Decide 151 (Decide 151)
;
278$          BRANCH,        1:
                             If,consume>0,914$,Yes:
                             Else,915$,Yes;
914$          ASSIGN:        Decide 151.NumberOut True=Decide 151.NumberOut True + 1:NEXT(98$);

915$          ASSIGN:        Decide 151.NumberOut False=Decide 151.NumberOut False + 1:NEXT(214$);


;
;
;     Model statements for module:  BasicProcess.Decide 133 (Check if fridge is empty or not older children)
;
260$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue) >0  || currentopenamount>0,916$,Yes:
                             Else,917$,Yes;
916$          ASSIGN:        Check if fridge is empty or not older children.NumberOut True=
                             Check if fridge is empty or not older children.NumberOut True + 1:NEXT(259$);

917$          ASSIGN:        Check if fridge is empty or not older children.NumberOut False=
                             Check if fridge is empty or not older children.NumberOut False + 1:NEXT(254$);


;
;
;     Model statements for module:  BasicProcess.Decide 132 (Probability of Consumption older children increase when frisge is not empty)
;
259$          BRANCH,        1:
                             With,(probabilityolder+notemptyfridgeincreaseprob)/100,918$,Yes:
                             Else,919$,Yes;
918$          ASSIGN:        Probability of Consumption older children increase when frisge is not empty.NumberOut True=
                             Probability of Consumption older children increase when frisge is not empty.NumberOut True + 1
                             :NEXT(214$);

919$          ASSIGN:        Probability of Consumption older children increase when frisge is not empty.NumberOut False=
                             Probability of Consumption older children increase when frisge is not empty.NumberOut False + 1
                             :NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Decide 130 (Check if there are unopened packages in the fridge older children)
;
257$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue)  >  0,920$,Yes:
                             Else,921$,Yes;
920$          ASSIGN:        Check if there are unopened packages in the fridge older children.NumberOut True=
                             Check if there are unopened packages in the fridge older children.NumberOut True + 1:NEXT(256$);

921$          ASSIGN:        Check if there are unopened packages in the fridge older children.NumberOut False=
                             Check if there are unopened packages in the fridge older children.NumberOut False + 1:NEXT(254$);


;
;
;     Model statements for module:  BasicProcess.Decide 129 (Probability of Consumption older children increased when there are unopened packages in the fridge)
;
256$          BRANCH,        1:
                             With,(probabilityolder+unopenedincreaseprob)/100,922$,Yes:
                             Else,923$,Yes;
922$          ASSIGN:        
                             Probability of Consumption older children increased when there are unopened packages in the fridge.NumberOut True=
                             Probability of Consumption older children increased when there are unopened packages in the fridge.NumberOut True + 1
                             :NEXT(214$);

923$          ASSIGN:        
                             Probability of Consumption older children increased when there are unopened packages in the fridge.NumberOut False=
                             Probability of Consumption older children increased when there are unopened packages in the fridge.NumberOut False + 1
                             :NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Decide 128 (Check if there are opened packages in the fridge older children)
;
255$          BRANCH,        1:
                             If,currentopenamount>0,924$,Yes:
                             Else,925$,Yes;
924$          ASSIGN:        Check if there are opened packages in the fridge older children.NumberOut True=
                             Check if there are opened packages in the fridge older children.NumberOut True + 1:NEXT(261$);

925$          ASSIGN:        Check if there are opened packages in the fridge older children.NumberOut False=
                             Check if there are opened packages in the fridge older children.NumberOut False + 1:NEXT(254$);


;
;
;     Model statements for module:  BasicProcess.Decide 134 (Probability of Consumption older children increased when there are opened packages in the fridge)
;
261$          BRANCH,        1:
                             With,(probabilityolder+openedincreaseprob)/100,926$,Yes:
                             Else,927$,Yes;
926$          ASSIGN:        
                             Probability of Consumption older children increased when there are opened packages in the fridge.NumberOut True=
                             Probability of Consumption older children increased when there are opened packages in the fridge.NumberOut True + 1
                             :NEXT(214$);

927$          ASSIGN:        
                             Probability of Consumption older children increased when there are opened packages in the fridge.NumberOut False=
                             Probability of Consumption older children increased when there are opened packages in the fridge.NumberOut False + 1
                             :NEXT(215$);


;
;
;     Model statements for module:  BasicProcess.Create 30 (For counting freezer usage)
;

928$          CREATE,        1,DaysToBaseTime(0.9),Entity 1:DaysToBaseTime(1):NEXT(929$);

929$          ASSIGN:        For counting freezer usage.NumberOut=For counting freezer usage.NumberOut + 1:NEXT(228$);


;
;
;     Model statements for module:  BasicProcess.Decide 90 (Decide 90)
;
228$          BRANCH,        1:
                             If,NQ(Unopened packages in freezer.Queue) > 0,932$,Yes:
                             Else,933$,Yes;
932$          ASSIGN:        Decide 90.NumberOut True=Decide 90.NumberOut True + 1:NEXT(229$);

933$          ASSIGN:        Decide 90.NumberOut False=Decide 90.NumberOut False + 1:NEXT(227$);


;
;
;     Model statements for module:  BasicProcess.Assign 138 (Count the number of days that the freezer has been used)
;
229$          ASSIGN:        activedaysfreezer=activedaysfreezer+1:NEXT(227$);


;
;
;     Model statements for module:  BasicProcess.Dispose 31 (Dispose 31)
;
227$          ASSIGN:        Dispose 31.NumberOut=Dispose 31.NumberOut + 1;
934$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Create 31 (For counting fridge usage)
;

935$          CREATE,        1,DaysToBaseTime(0.9),Entity 1:DaysToBaseTime(1):NEXT(936$);

936$          ASSIGN:        For counting fridge usage.NumberOut=For counting fridge usage.NumberOut + 1:NEXT(231$);


;
;
;     Model statements for module:  BasicProcess.Decide 91 (Decide 91)
;
231$          BRANCH,        1:
                             If,NQ(Unopened packages.Queue)> 0  || currentopenamount>0,939$,Yes:
                             Else,940$,Yes;
939$          ASSIGN:        Decide 91.NumberOut True=Decide 91.NumberOut True + 1:NEXT(232$);

940$          ASSIGN:        Decide 91.NumberOut False=Decide 91.NumberOut False + 1:NEXT(230$);


;
;
;     Model statements for module:  BasicProcess.Assign 139 (Count the number of days that the fridge has been used)
;
232$          ASSIGN:        activedaysfridge=activedaysfridge+1:NEXT(230$);


;
;
;     Model statements for module:  BasicProcess.Dispose 32 (Dispose 32)
;
230$          ASSIGN:        Dispose 32.NumberOut=Dispose 32.NumberOut + 1;
941$          DISPOSE:       Yes;


;
;
;     Model statements for module:  BasicProcess.Create 32 (Opportunity to consume directly)
;

942$          CREATE,        opportunitynumberdirectlyconsume*people,DaysToBaseTime(0.2),drinking:
                             DaysToBaseTime(opportunitydirectly):NEXT(943$);

943$          ASSIGN:        Opportunity to consume directly.NumberOut=Opportunity to consume directly.NumberOut + 1:NEXT(238$);


;
;
;     Model statements for module:  BasicProcess.Decide 92 (Probability of Consumption for Directly)
;
238$          BRANCH,        1:
                             With,(probabilitydirectly)/100,946$,Yes:
                             Else,947$,Yes;
946$          ASSIGN:        Probability of Consumption for Directly.NumberOut True=
                             Probability of Consumption for Directly.NumberOut True + 1:NEXT(239$);

947$          ASSIGN:        Probability of Consumption for Directly.NumberOut False=
                             Probability of Consumption for Directly.NumberOut False + 1:NEXT(240$);


;
;
;     Model statements for module:  BasicProcess.Assign 141 (Consumption amount for directly)
;
239$          ASSIGN:        consume=ANINT(consumptiondirectly):NEXT(275$);


;
;
;     Model statements for module:  BasicProcess.Label 1
;
openpack      DELAY:         0,,Other:NEXT(70$);