r = 60 ;
s = 60;
udr = 30;
a = 60;

EvcEgoprat= (lrateg, a).EvcEgRecrat ;
EvcEgoprbt= (lrbteg, a).EvcEgRecrbt ;
EvcEgoprct= (lrcteg, a).EvcEgRecrct ;
EvcEgophat= (lhateg, a).EvcEgRechat ;
EvcEgoplwt= (llwteg, a).EvcEgReclwt ;
EvcEgoplet= (lleteg, a).EvcEgReclet ;
EvcEgopset= (lseteg, a).EvcEgRecset ;
EvcEgopswt= (lswteg, a).EvcEgRecswt ;
EvcEgopras= (lraseg, a).EvcEgRecras ;
EvcEgopses= (lseseg, a).EvcEgRecses ;
EvcEgoples= (lleseg, a).EvcEgRecles ;
EvcEgophas= (lhaseg, a).EvcEgRechas ;
EvcEgoplws= (llwseg, a).EvcEgReclws ;
EvcEgopsws= (lswseg, a).EvcEgRecsws ;
EvcEgoprbs= (lrbseg, a).EvcEgRecrbs ;
EvcEgopoag= (loageg, a).EvcEgRecoag ;
EvcEgophbg= (lhbgeg, a).EvcEgRechbg ;
EvcEgophag= (lhageg, a).EvcEgRechag ;
EvcEgophcg= (lhcgeg, a).EvcEgRechcg ;
EvcEgoprag= (lrageg, a).EvcEgRecrag ;
EvcEgopf= (lfeg, a).EvcEgRecf ;

EvcEfoprat= (lratef, a).EvcEfRecrat ;
EvcEfoprbt= (lrbtef, a).EvcEfRecrbt ;
EvcEfoprct= (lrctef, a).EvcEfRecrct ;
EvcEfophat= (lhatef, a).EvcEfRechat ;
EvcEfoplwt= (llwtef, a).EvcEfReclwt ;
EvcEfoplet= (lletef, a).EvcEfReclet ;
EvcEfopset= (lsetef, a).EvcEfRecset ;
EvcEfopswt= (lswtef, a).EvcEfRecswt ;
EvcEfopras= (lrasef, a).EvcEfRecras ;
EvcEfopses= (lsesef, a).EvcEfRecses ;
EvcEfoples= (llesef, a).EvcEfRecles ;
EvcEfophas= (lhasef, a).EvcEfRechas ;
EvcEfoplws= (llwsef, a).EvcEfReclws ;
EvcEfopsws= (lswsef, a).EvcEfRecsws ;
EvcEfoprbs= (lrbsef, a).EvcEfRecrbs ;
EvcEfopoag= (loagef, a).EvcEfRecoag ;
EvcEfophbg= (lhbgef, a).EvcEfRechbg ;
EvcEfophag= (lhagef, a).EvcEfRechag ;
EvcEfophcg= (lhcgef, a).EvcEfRechcg ;
EvcEfoprag= (lragef, a).EvcEfRecrag ;
EvcEfopg= (lgef, a).EvcEfRecg ;



EvcEgFratThat= (rathat, udr).EvcEgEnterLhatFrat;
EvcEgEnterLhatFrat = (lhatop, s).EvcEgEnterLhatFratfp ;
EvcEgEnterLhatFratfp = (lratfp, s).EvcEgophat;

EvcEgFrbtThat= (rbthat, udr).EvcEgEnterLhatFrbt;
EvcEgEnterLhatFrbt = (lhatop, s).EvcEgEnterLhatFrbtfp ;
EvcEgEnterLhatFrbtfp = (lrbtfp, s).EvcEgophat;

EvcEgFrctThat= (rcthat, udr).EvcEgEnterLhatFrct;
EvcEgEnterLhatFrct = (lhatop, s).EvcEgEnterLhatFrctfp ;
EvcEgEnterLhatFrctfp = (lrctfp, s).EvcEgophat;

EvcEgFhatTrat= (rathat, udr).EvcEgEnterLratFhat;
EvcEgEnterLratFhat = (lratop, s).EvcEgEnterLratFhatfp ;
EvcEgEnterLratFhatfp = (lhatfp, s).EvcEgoprat;

EvcEgFhatTrbt= (rbthat, udr).EvcEgEnterLrbtFhat;
EvcEgEnterLrbtFhat = (lrbtop, s).EvcEgEnterLrbtFhatfp ;
EvcEgEnterLrbtFhatfp = (lhatfp, s).EvcEgoprbt;

EvcEgFhatTrct= (rcthat, udr).EvcEgEnterLrctFhat;
EvcEgEnterLrctFhat = (lrctop, s).EvcEgEnterLrctFhatfp ;
EvcEgEnterLrctFhatfp = (lhatfp, s).EvcEgoprct;

EvcEgFhatTlwt= (hatlwt, udr).EvcEgEnterLlwtFhat;
EvcEgEnterLlwtFhat = (llwtop, s).EvcEgEnterLlwtFhatfp ;
EvcEgEnterLlwtFhatfp = (lhatfp, s).EvcEgoplwt;

EvcEgFhatTlet= (hatlet, udr).EvcEgEnterLletFhat;
EvcEgEnterLletFhat = (lletop, s).EvcEgEnterLletFhatfp ;
EvcEgEnterLletFhatfp = (lhatfp, s).EvcEgoplet;

EvcEgFlwtThat= (hatlwt, udr).EvcEgEnterLhatFlwt;
EvcEgEnterLhatFlwt = (lhatop, s).EvcEgEnterLhatFlwtfp ;
EvcEgEnterLhatFlwtfp = (llwtfp, s).EvcEgophat;

EvcEgFlwtTswt= (lwtswt, udr).EvcEgEnterLswtFlwt;
EvcEgEnterLswtFlwt = (lswtop, s).EvcEgEnterLswtFlwtfp ;
EvcEgEnterLswtFlwtfp = (llwtfp, s).EvcEgopswt;

EvcEgFletThat= (hatlet, udr).EvcEgEnterLhatFlet;
EvcEgEnterLhatFlet = (lhatop, s).EvcEgEnterLhatFletfp ;
EvcEgEnterLhatFletfp = (lletfp, s).EvcEgophat;

EvcEgFletTset= (letset, udr).EvcEgEnterLsetFlet;
EvcEgEnterLsetFlet = (lsetop, s).EvcEgEnterLsetFletfp ;
EvcEgEnterLsetFletfp = (lletfp, s).EvcEgopset;

EvcEgFsetTlet= (letset, udr).EvcEgEnterLletFset;
EvcEgEnterLletFset = (lletop, s).EvcEgEnterLletFsetfp ;
EvcEgEnterLletFsetfp = (lsetfp, s).EvcEgoplet;

EvcEgFsetTles= (setles, udr).EvcEgEnterLlesFset;
EvcEgEnterLlesFset = (llesop, s).EvcEgEnterLlesFsetfp ;
EvcEgEnterLlesFsetfp = (lsetfp, s).EvcEgoples;

EvcEgFswtTlwt= (lwtswt, udr).EvcEgEnterLlwtFswt;
EvcEgEnterLlwtFswt = (llwtop, s).EvcEgEnterLlwtFswtfp ;
EvcEgEnterLlwtFswtfp = (lswtfp, s).EvcEgoplwt;

EvcEgFswtTlws= (swtlws, udr).EvcEgEnterLlwsFswt;
EvcEgEnterLlwsFswt = (llwsop, s).EvcEgEnterLlwsFswtfp ;
EvcEgEnterLlwsFswtfp = (lswtfp, s).EvcEgoplws;

EvcEgFlesTset= (setles, udr).EvcEgEnterLsetFles;
EvcEgEnterLsetFles = (lsetop, s).EvcEgEnterLsetFlesfp ;
EvcEgEnterLsetFlesfp = (llesfp, s).EvcEgopset;

EvcEgFlesTses= (lesses, udr).EvcEgEnterLsesFles;
EvcEgEnterLsesFles = (lsesop, s).EvcEgEnterLsesFlesfp ;
EvcEgEnterLsesFlesfp = (llesfp, s).EvcEgopses;

EvcEgFlesThas= (leshas, udr).EvcEgEnterLhasFles;
EvcEgEnterLhasFles = (lhasop, s).EvcEgEnterLhasFlesfp ;
EvcEgEnterLhasFlesfp = (llesfp, s).EvcEgophas;

EvcEgFhasTras= (hasras, udr).EvcEgEnterLrasFhas;
EvcEgEnterLrasFhas = (lrasop, s).EvcEgEnterLrasFhasfp ;
EvcEgEnterLrasFhasfp = (lhasfp, s).EvcEgopras;

EvcEgFhasTles= (leshas, udr).EvcEgEnterLlesFhas;
EvcEgEnterLlesFhas = (llesop, s).EvcEgEnterLlesFhasfp ;
EvcEgEnterLlesFhasfp = (lhasfp, s).EvcEgoples;

EvcEgFhasTrbs= (hasrbs, udr).EvcEgEnterLrbsFhas;
EvcEgEnterLrbsFhas = (lrbsop, s).EvcEgEnterLrbsFhasfp ;
EvcEgEnterLrbsFhasfp = (lhasfp, s).EvcEgoprbs;

EvcEgFhasTlws= (haslws, udr).EvcEgEnterLlwsFhas;
EvcEgEnterLlwsFhas = (llwsop, s).EvcEgEnterLlwsFhasfp ;
EvcEgEnterLlwsFhasfp = (lhasfp, s).EvcEgoplws;

EvcEgFrasThas= (hasras, udr).EvcEgEnterLhasFras;
EvcEgEnterLhasFras = (lhasop, s).EvcEgEnterLhasFrasfp ;
EvcEgEnterLhasFrasfp = (lrasfp, s).EvcEgophas;

EvcEgFrbsThas= (hasrbs, udr).EvcEgEnterLhasFrbs;
EvcEgEnterLhasFrbs = (lhasop, s).EvcEgEnterLhasFrbsfp ;
EvcEgEnterLhasFrbsfp = (lrbsfp, s).EvcEgophas;

EvcEgFlwsThas= (haslws, udr).EvcEgEnterLhasFlws;
EvcEgEnterLhasFlws = (lhasop, s).EvcEgEnterLhasFlwsfp ;
EvcEgEnterLhasFlwsfp = (llwsfp, s).EvcEgophas;

EvcEgFlwsTsws= (lwssws, udr).EvcEgEnterLswsFlws;
EvcEgEnterLswsFlws = (lswsop, s).EvcEgEnterLswsFlwsfp ;
EvcEgEnterLswsFlwsfp = (llwsfp, s).EvcEgopsws;

EvcEgFlwsTswt= (swtlws, udr).EvcEgEnterLswtFlws;
EvcEgEnterLswtFlws = (lswtop, s).EvcEgEnterLswtFlwsfp ;
EvcEgEnterLswtFlwsfp = (llwsfp, s).EvcEgopswt;

EvcEgFsesTles= (lesses, udr).EvcEgEnterLlesFses;
EvcEgEnterLlesFses = (llesop, s).EvcEgEnterLlesFsesfp ;
EvcEgEnterLlesFsesfp = (lsesfp, s).EvcEgoples;

EvcEgFsesThcg= (seshcg, udr).EvcEgEnterLhcgFses;
EvcEgEnterLhcgFses = (lhcgop, s).EvcEgEnterLhcgFsesfp ;
EvcEgEnterLhcgFsesfp = (lsesfp, s).EvcEgophcg;

EvcEgFhcgTses= (seshcg, udr).EvcEgEnterLsesFhcg;
EvcEgEnterLsesFhcg = (lsesop, s).EvcEgEnterLsesFhcgfp ;
EvcEgEnterLsesFhcgfp = (lhcgfp, s).EvcEgopses;

EvcEgFswsTlws= (lwssws, udr).EvcEgEnterLlwsFsws;
EvcEgEnterLlwsFsws = (llwsop, s).EvcEgEnterLlwsFswsfp ;
EvcEgEnterLlwsFswsfp = (lswsfp, s).EvcEgoplws;

EvcEgFswsToag= (swsoag, udr).EvcEgEnterLoagFsws;
EvcEgEnterLoagFsws = (loagop, s).EvcEgEnterLoagFswsfp ;
EvcEgEnterLoagFswsfp = (lswsfp, s).EvcEgopoag;

EvcEgFoagTsws= (swsoag, udr).EvcEgEnterLswsFoag;
EvcEgEnterLswsFoag = (lswsop, s).EvcEgEnterLswsFoagfp ;
EvcEgEnterLswsFoagfp = (loagfp, s).EvcEgopsws;

EvcEgFoagTg= (oagg, udr).EvcEgEnterLgFoag;
EvcEgEnterLgFoag = (lgop, s).EvcEgEnterLgFoagfp ;
EvcEgEnterLgFoagfp = (loagfp, s).EvcEgfpg;
EvcEgfpg = (lgfp, s).EvcEgArrived ;

EvcEgFoagThbg= (oaghbg, udr).EvcEgEnterLhbgFoag;
EvcEgEnterLhbgFoag = (lhbgop, s).EvcEgEnterLhbgFoagfp ;
EvcEgEnterLhbgFoagfp = (loagfp, s).EvcEgophbg;

EvcEgFoagThag= (oaghag, udr).EvcEgEnterLhagFoag;
EvcEgEnterLhagFoag = (lhagop, s).EvcEgEnterLhagFoagfp ;
EvcEgEnterLhagFoagfp = (loagfp, s).EvcEgophag;

EvcEgFoagTrag= (oagrag, udr).EvcEgEnterLragFoag;
EvcEgEnterLragFoag = (lragop, s).EvcEgEnterLragFoagfp ;
EvcEgEnterLragFoagfp = (loagfp, s).EvcEgoprag;

EvcEgFgToag= (oagg, udr).EvcEgEnterLoagFg;
EvcEgEnterLoagFg = (loagop, s).EvcEgEnterLoagFgfp ;
EvcEgEnterLoagFgfp = (lgfp, s).EvcEgopoag;

EvcEgFhbgToag= (oaghbg, udr).EvcEgEnterLoagFhbg;
EvcEgEnterLoagFhbg = (loagop, s).EvcEgEnterLoagFhbgfp ;
EvcEgEnterLoagFhbgfp = (lhbgfp, s).EvcEgopoag;

EvcEgFhagToag= (oaghag, udr).EvcEgEnterLoagFhag;
EvcEgEnterLoagFhag = (loagop, s).EvcEgEnterLoagFhagfp ;
EvcEgEnterLoagFhagfp = (lhagfp, s).EvcEgopoag;

EvcEgFhbgThcg= (hbghcg, udr).EvcEgEnterLhcgFhbg;
EvcEgEnterLhcgFhbg = (lhcgop, s).EvcEgEnterLhcgFhbgfp ;
EvcEgEnterLhcgFhbgfp = (lhbgfp, s).EvcEgophcg;

EvcEgFhbgTrag= (hbgrag, udr).EvcEgEnterLragFhbg;
EvcEgEnterLragFhbg = (lragop, s).EvcEgEnterLragFhbgfp ;
EvcEgEnterLragFhbgfp = (lhbgfp, s).EvcEgoprag;

EvcEgFhcgThbg= (hbghcg, udr).EvcEgEnterLhbgFhcg;
EvcEgEnterLhbgFhcg = (lhbgop, s).EvcEgEnterLhbgFhcgfp ;
EvcEgEnterLhbgFhcgfp = (lhcgfp, s).EvcEgophbg;

EvcEgFhagThcg= (haghcg, udr).EvcEgEnterLhcgFhag;
EvcEgEnterLhcgFhag = (lhcgop, s).EvcEgEnterLhcgFhagfp ;
EvcEgEnterLhcgFhagfp = (lhagfp, s).EvcEgophcg;

EvcEgFhcgThag= (haghcg, udr).EvcEgEnterLhagFhcg;
EvcEgEnterLhagFhcg = (lhagop, s).EvcEgEnterLhagFhcgfp ;
EvcEgEnterLhagFhcgfp = (lhcgfp, s).EvcEgophag;

EvcEgFhcgTrag= (hcgrag, udr).EvcEgEnterLragFhcg;
EvcEgEnterLragFhcg = (lragop, s).EvcEgEnterLragFhcgfp ;
EvcEgEnterLragFhcgfp = (lhcgfp, s).EvcEgoprag;

EvcEgFragThbg= (hbgrag, udr).EvcEgEnterLhbgFrag;
EvcEgEnterLhbgFrag = (lhbgop, s).EvcEgEnterLhbgFragfp ;
EvcEgEnterLhbgFragfp = (lragfp, s).EvcEgophbg;

EvcEgFragThcg= (hcgrag, udr).EvcEgEnterLhcgFrag;
EvcEgEnterLhcgFrag = (lhcgop, s).EvcEgEnterLhcgFragfp ;
EvcEgEnterLhcgFragfp = (lragfp, s).EvcEgophcg;

EvcEgFragToag= (oagrag, udr).EvcEgEnterLoagFrag;
EvcEgEnterLoagFrag = (loagop, s).EvcEgEnterLoagFragfp ;
EvcEgEnterLoagFragfp = (lragfp, s).EvcEgopoag;

EvcEgFhcgTf= (hcgf, udr).EvcEgEnterLfFhcg;
EvcEgEnterLfFhcg = (lfop, s).EvcEgEnterLfFhcgfp ;
EvcEgEnterLfFhcgfp = (lhcgfp, s).EvcEgopf;

EvcEgFhagTf= (hagf, udr).EvcEgEnterLfFhag;
EvcEgEnterLfFhag = (lfop, s).EvcEgEnterLfFhagfp ;
EvcEgEnterLfFhagfp = (lhagfp, s).EvcEgopf;

EvcEgFfThcg= (hcgf, udr).EvcEgEnterLhcgFf;
EvcEgEnterLhcgFf = (lhcgop, s).EvcEgEnterLhcgFffp ;
EvcEgEnterLhcgFffp = (lffp, s).EvcEgophcg;

EvcEgFfThag= (hagf, udr).EvcEgEnterLhagFf;
EvcEgEnterLhagFf = (lhagop, s).EvcEgEnterLhagFffp ;
EvcEgEnterLhagFffp = (lffp, s).EvcEgophag;

EvcEgArrived =  (nop, a).EvcEgArrived ;

EvcEfFratThat= (rathat, udr).EvcEfEnterLhatFrat;
EvcEfEnterLhatFrat = (lhatop, s).EvcEfEnterLhatFratfp ;
EvcEfEnterLhatFratfp = (lratfp, s).EvcEfophat;

EvcEfFrbtThat= (rbthat, udr).EvcEfEnterLhatFrbt;
EvcEfEnterLhatFrbt = (lhatop, s).EvcEfEnterLhatFrbtfp ;
EvcEfEnterLhatFrbtfp = (lrbtfp, s).EvcEfophat;

EvcEfFrctThat= (rcthat, udr).EvcEfEnterLhatFrct;
EvcEfEnterLhatFrct = (lhatop, s).EvcEfEnterLhatFrctfp ;
EvcEfEnterLhatFrctfp = (lrctfp, s).EvcEfophat;

EvcEfFhatTrat= (rathat, udr).EvcEfEnterLratFhat;
EvcEfEnterLratFhat = (lratop, s).EvcEfEnterLratFhatfp ;
EvcEfEnterLratFhatfp = (lhatfp, s).EvcEfoprat;

EvcEfFhatTrbt= (rbthat, udr).EvcEfEnterLrbtFhat;
EvcEfEnterLrbtFhat = (lrbtop, s).EvcEfEnterLrbtFhatfp ;
EvcEfEnterLrbtFhatfp = (lhatfp, s).EvcEfoprbt;

EvcEfFhatTrct= (rcthat, udr).EvcEfEnterLrctFhat;
EvcEfEnterLrctFhat = (lrctop, s).EvcEfEnterLrctFhatfp ;
EvcEfEnterLrctFhatfp = (lhatfp, s).EvcEfoprct;

EvcEfFhatTlwt= (hatlwt, udr).EvcEfEnterLlwtFhat;
EvcEfEnterLlwtFhat = (llwtop, s).EvcEfEnterLlwtFhatfp ;
EvcEfEnterLlwtFhatfp = (lhatfp, s).EvcEfoplwt;

EvcEfFhatTlet= (hatlet, udr).EvcEfEnterLletFhat;
EvcEfEnterLletFhat = (lletop, s).EvcEfEnterLletFhatfp ;
EvcEfEnterLletFhatfp = (lhatfp, s).EvcEfoplet;

EvcEfFlwtThat= (hatlwt, udr).EvcEfEnterLhatFlwt;
EvcEfEnterLhatFlwt = (lhatop, s).EvcEfEnterLhatFlwtfp ;
EvcEfEnterLhatFlwtfp = (llwtfp, s).EvcEfophat;

EvcEfFlwtTswt= (lwtswt, udr).EvcEfEnterLswtFlwt;
EvcEfEnterLswtFlwt = (lswtop, s).EvcEfEnterLswtFlwtfp ;
EvcEfEnterLswtFlwtfp = (llwtfp, s).EvcEfopswt;

EvcEfFletThat= (hatlet, udr).EvcEfEnterLhatFlet;
EvcEfEnterLhatFlet = (lhatop, s).EvcEfEnterLhatFletfp ;
EvcEfEnterLhatFletfp = (lletfp, s).EvcEfophat;

EvcEfFletTset= (letset, udr).EvcEfEnterLsetFlet;
EvcEfEnterLsetFlet = (lsetop, s).EvcEfEnterLsetFletfp ;
EvcEfEnterLsetFletfp = (lletfp, s).EvcEfopset;

EvcEfFsetTlet= (letset, udr).EvcEfEnterLletFset;
EvcEfEnterLletFset = (lletop, s).EvcEfEnterLletFsetfp ;
EvcEfEnterLletFsetfp = (lsetfp, s).EvcEfoplet;

EvcEfFsetTles= (setles, udr).EvcEfEnterLlesFset;
EvcEfEnterLlesFset = (llesop, s).EvcEfEnterLlesFsetfp ;
EvcEfEnterLlesFsetfp = (lsetfp, s).EvcEfoples;

EvcEfFswtTlwt= (lwtswt, udr).EvcEfEnterLlwtFswt;
EvcEfEnterLlwtFswt = (llwtop, s).EvcEfEnterLlwtFswtfp ;
EvcEfEnterLlwtFswtfp = (lswtfp, s).EvcEfoplwt;

EvcEfFswtTlws= (swtlws, udr).EvcEfEnterLlwsFswt;
EvcEfEnterLlwsFswt = (llwsop, s).EvcEfEnterLlwsFswtfp ;
EvcEfEnterLlwsFswtfp = (lswtfp, s).EvcEfoplws;

EvcEfFlesTset= (setles, udr).EvcEfEnterLsetFles;
EvcEfEnterLsetFles = (lsetop, s).EvcEfEnterLsetFlesfp ;
EvcEfEnterLsetFlesfp = (llesfp, s).EvcEfopset;

EvcEfFlesTses= (lesses, udr).EvcEfEnterLsesFles;
EvcEfEnterLsesFles = (lsesop, s).EvcEfEnterLsesFlesfp ;
EvcEfEnterLsesFlesfp = (llesfp, s).EvcEfopses;

EvcEfFlesThas= (leshas, udr).EvcEfEnterLhasFles;
EvcEfEnterLhasFles = (lhasop, s).EvcEfEnterLhasFlesfp ;
EvcEfEnterLhasFlesfp = (llesfp, s).EvcEfophas;

EvcEfFhasTras= (hasras, udr).EvcEfEnterLrasFhas;
EvcEfEnterLrasFhas = (lrasop, s).EvcEfEnterLrasFhasfp ;
EvcEfEnterLrasFhasfp = (lhasfp, s).EvcEfopras;

EvcEfFhasTles= (leshas, udr).EvcEfEnterLlesFhas;
EvcEfEnterLlesFhas = (llesop, s).EvcEfEnterLlesFhasfp ;
EvcEfEnterLlesFhasfp = (lhasfp, s).EvcEfoples;

EvcEfFhasTrbs= (hasrbs, udr).EvcEfEnterLrbsFhas;
EvcEfEnterLrbsFhas = (lrbsop, s).EvcEfEnterLrbsFhasfp ;
EvcEfEnterLrbsFhasfp = (lhasfp, s).EvcEfoprbs;

EvcEfFhasTlws= (haslws, udr).EvcEfEnterLlwsFhas;
EvcEfEnterLlwsFhas = (llwsop, s).EvcEfEnterLlwsFhasfp ;
EvcEfEnterLlwsFhasfp = (lhasfp, s).EvcEfoplws;

EvcEfFrasThas= (hasras, udr).EvcEfEnterLhasFras;
EvcEfEnterLhasFras = (lhasop, s).EvcEfEnterLhasFrasfp ;
EvcEfEnterLhasFrasfp = (lrasfp, s).EvcEfophas;

EvcEfFrbsThas= (hasrbs, udr).EvcEfEnterLhasFrbs;
EvcEfEnterLhasFrbs = (lhasop, s).EvcEfEnterLhasFrbsfp ;
EvcEfEnterLhasFrbsfp = (lrbsfp, s).EvcEfophas;

EvcEfFlwsThas= (haslws, udr).EvcEfEnterLhasFlws;
EvcEfEnterLhasFlws = (lhasop, s).EvcEfEnterLhasFlwsfp ;
EvcEfEnterLhasFlwsfp = (llwsfp, s).EvcEfophas;

EvcEfFlwsTsws= (lwssws, udr).EvcEfEnterLswsFlws;
EvcEfEnterLswsFlws = (lswsop, s).EvcEfEnterLswsFlwsfp ;
EvcEfEnterLswsFlwsfp = (llwsfp, s).EvcEfopsws;

EvcEfFlwsTswt= (swtlws, udr).EvcEfEnterLswtFlws;
EvcEfEnterLswtFlws = (lswtop, s).EvcEfEnterLswtFlwsfp ;
EvcEfEnterLswtFlwsfp = (llwsfp, s).EvcEfopswt;

EvcEfFsesTles= (lesses, udr).EvcEfEnterLlesFses;
EvcEfEnterLlesFses = (llesop, s).EvcEfEnterLlesFsesfp ;
EvcEfEnterLlesFsesfp = (lsesfp, s).EvcEfoples;

EvcEfFsesThcg= (seshcg, udr).EvcEfEnterLhcgFses;
EvcEfEnterLhcgFses = (lhcgop, s).EvcEfEnterLhcgFsesfp ;
EvcEfEnterLhcgFsesfp = (lsesfp, s).EvcEfophcg;

EvcEfFhcgTses= (seshcg, udr).EvcEfEnterLsesFhcg;
EvcEfEnterLsesFhcg = (lsesop, s).EvcEfEnterLsesFhcgfp ;
EvcEfEnterLsesFhcgfp = (lhcgfp, s).EvcEfopses;

EvcEfFswsTlws= (lwssws, udr).EvcEfEnterLlwsFsws;
EvcEfEnterLlwsFsws = (llwsop, s).EvcEfEnterLlwsFswsfp ;
EvcEfEnterLlwsFswsfp = (lswsfp, s).EvcEfoplws;

EvcEfFswsToag= (swsoag, udr).EvcEfEnterLoagFsws;
EvcEfEnterLoagFsws = (loagop, s).EvcEfEnterLoagFswsfp ;
EvcEfEnterLoagFswsfp = (lswsfp, s).EvcEfopoag;

EvcEfFoagTsws= (swsoag, udr).EvcEfEnterLswsFoag;
EvcEfEnterLswsFoag = (lswsop, s).EvcEfEnterLswsFoagfp ;
EvcEfEnterLswsFoagfp = (loagfp, s).EvcEfopsws;

EvcEfFoagTg= (oagg, udr).EvcEfEnterLgFoag;
EvcEfEnterLgFoag = (lgop, s).EvcEfEnterLgFoagfp ;
EvcEfEnterLgFoagfp = (loagfp, s).EvcEfopg;

EvcEfFoagThbg= (oaghbg, udr).EvcEfEnterLhbgFoag;
EvcEfEnterLhbgFoag = (lhbgop, s).EvcEfEnterLhbgFoagfp ;
EvcEfEnterLhbgFoagfp = (loagfp, s).EvcEfophbg;

EvcEfFoagThag= (oaghag, udr).EvcEfEnterLhagFoag;
EvcEfEnterLhagFoag = (lhagop, s).EvcEfEnterLhagFoagfp ;
EvcEfEnterLhagFoagfp = (loagfp, s).EvcEfophag;

EvcEfFoagTrag= (oagrag, udr).EvcEfEnterLragFoag;
EvcEfEnterLragFoag = (lragop, s).EvcEfEnterLragFoagfp ;
EvcEfEnterLragFoagfp = (loagfp, s).EvcEfoprag;

EvcEfFgToag= (oagg, udr).EvcEfEnterLoagFg;
EvcEfEnterLoagFg = (loagop, s).EvcEfEnterLoagFgfp ;
EvcEfEnterLoagFgfp = (lgfp, s).EvcEfopoag;

EvcEfFhbgToag= (oaghbg, udr).EvcEfEnterLoagFhbg;
EvcEfEnterLoagFhbg = (loagop, s).EvcEfEnterLoagFhbgfp ;
EvcEfEnterLoagFhbgfp = (lhbgfp, s).EvcEfopoag;

EvcEfFhagToag= (oaghag, udr).EvcEfEnterLoagFhag;
EvcEfEnterLoagFhag = (loagop, s).EvcEfEnterLoagFhagfp ;
EvcEfEnterLoagFhagfp = (lhagfp, s).EvcEfopoag;

EvcEfFhbgThcg= (hbghcg, udr).EvcEfEnterLhcgFhbg;
EvcEfEnterLhcgFhbg = (lhcgop, s).EvcEfEnterLhcgFhbgfp ;
EvcEfEnterLhcgFhbgfp = (lhbgfp, s).EvcEfophcg;

EvcEfFhbgTrag= (hbgrag, udr).EvcEfEnterLragFhbg;
EvcEfEnterLragFhbg = (lragop, s).EvcEfEnterLragFhbgfp ;
EvcEfEnterLragFhbgfp = (lhbgfp, s).EvcEfoprag;

EvcEfFhcgThbg= (hbghcg, udr).EvcEfEnterLhbgFhcg;
EvcEfEnterLhbgFhcg = (lhbgop, s).EvcEfEnterLhbgFhcgfp ;
EvcEfEnterLhbgFhcgfp = (lhcgfp, s).EvcEfophbg;

EvcEfFhagThcg= (haghcg, udr).EvcEfEnterLhcgFhag;
EvcEfEnterLhcgFhag = (lhcgop, s).EvcEfEnterLhcgFhagfp ;
EvcEfEnterLhcgFhagfp = (lhagfp, s).EvcEfophcg;

EvcEfFhcgThag= (haghcg, udr).EvcEfEnterLhagFhcg;
EvcEfEnterLhagFhcg = (lhagop, s).EvcEfEnterLhagFhcgfp ;
EvcEfEnterLhagFhcgfp = (lhcgfp, s).EvcEfophag;

EvcEfFhcgTrag= (hcgrag, udr).EvcEfEnterLragFhcg;
EvcEfEnterLragFhcg = (lragop, s).EvcEfEnterLragFhcgfp ;
EvcEfEnterLragFhcgfp = (lhcgfp, s).EvcEfoprag;

EvcEfFragThbg= (hbgrag, udr).EvcEfEnterLhbgFrag;
EvcEfEnterLhbgFrag = (lhbgop, s).EvcEfEnterLhbgFragfp ;
EvcEfEnterLhbgFragfp = (lragfp, s).EvcEfophbg;

EvcEfFragThcg= (hcgrag, udr).EvcEfEnterLhcgFrag;
EvcEfEnterLhcgFrag = (lhcgop, s).EvcEfEnterLhcgFragfp ;
EvcEfEnterLhcgFragfp = (lragfp, s).EvcEfophcg;

EvcEfFragToag= (oagrag, udr).EvcEfEnterLoagFrag;
EvcEfEnterLoagFrag = (loagop, s).EvcEfEnterLoagFragfp ;
EvcEfEnterLoagFragfp = (lragfp, s).EvcEfopoag;

EvcEfFhcgTf= (hcgf, udr).EvcEfEnterLfFhcg;
EvcEfEnterLfFhcg = (lfop, s).EvcEfEnterLfFhcgfp ;
EvcEfEnterLfFhcgfp = (lhcgfp, s).EvcEffpf;

EvcEfFhagTf= (hagf, udr).EvcEfEnterLfFhag;
EvcEfEnterLfFhag = (lfop, s).EvcEfEnterLfFhagfp ;
EvcEfEnterLfFhagfp = (lhagfp, s).EvcEffpf;
EvcEffpf = (lffp, s).EvcEfArrived ;

EvcEfFfThcg= (hcgf, udr).EvcEfEnterLhcgFf;
EvcEfEnterLhcgFf = (lhcgop, s).EvcEfEnterLhcgFffp ;
EvcEfEnterLhcgFffp = (lffp, s).EvcEfophcg;

EvcEfFfThag= (hagf, udr).EvcEfEnterLhagFf;
EvcEfEnterLhagFf = (lhagop, s).EvcEfEnterLhagFffp ;
EvcEfEnterLhagFffp = (lffp, s).EvcEfophag;

EvcEfArrived =  (nop, a).EvcEfArrived ;



EvcEgRecrat = (egratlhat, r).MveEgFratThat ;
MveEgFratThat = (nop, 0.8571428571428571).EvcEgFratThat ;
EvcEgRecrbt = (egrbtlhat, r).MveEgFrbtThat ;
MveEgFrbtThat = (nop, 0.8571428571428571).EvcEgFrbtThat ;
EvcEgRecrct = (egrctlhat, r).MveEgFrctThat ;
MveEgFrctThat = (nop, 0.8571428571428571).EvcEgFrctThat ;
EvcEgRechat = (eghatlrat, r).MveEgFhatTrat +
            (eghatlrbt, r).MveEgFhatTrbt +
            (eghatlrct, r).MveEgFhatTrct +
            (eghatllwt, r).MveEgFhatTlwt +
            (eghatllet, r).MveEgFhatTlet ;
MveEgFhatTrat = (nop, 1.2).EvcEgFhatTrat ;
MveEgFhatTrbt = (nop, 1.2).EvcEgFhatTrbt ;
MveEgFhatTrct = (nop, 1.2).EvcEgFhatTrct ;
MveEgFhatTlwt = (nop, 0.4).EvcEgFhatTlwt ;
MveEgFhatTlet = (nop, 0.4).EvcEgFhatTlet ;
EvcEgReclwt = (eglwtlhat, r).MveEgFlwtThat +
            (eglwtlswt, r).MveEgFlwtTswt ;
MveEgFlwtThat = (nop, 0.6).EvcEgFlwtThat ;
MveEgFlwtTswt = (nop, 0.6).EvcEgFlwtTswt ;
EvcEgReclet = (egletlhat, r).MveEgFletThat +
            (egletlset, r).MveEgFletTset ;
MveEgFletThat = (nop, 0.6).EvcEgFletThat ;
MveEgFletTset = (nop, 0.6).EvcEgFletTset ;
EvcEgRecset = (egsetllet, r).MveEgFsetTlet +
            (egsetlles, r).MveEgFsetTles ;
MveEgFsetTlet = (nop, 0.6).EvcEgFsetTlet ;
MveEgFsetTles = (nop, 0.6).EvcEgFsetTles ;
EvcEgRecswt = (egswtllwt, r).MveEgFswtTlwt +
            (egswtllws, r).MveEgFswtTlws ;
MveEgFswtTlwt = (nop, 0.6).EvcEgFswtTlwt ;
MveEgFswtTlws = (nop, 0.6).EvcEgFswtTlws ;
EvcEgRecras = (egraslhas, r).MveEgFrasThas ;
MveEgFrasThas = (nop, 0.8571428571428571).EvcEgFrasThas ;
EvcEgRecses = (egseslles, r).MveEgFsesTles +
            (egseslhcg, r).MveEgFsesThcg ;
MveEgFsesTles = (nop, 0.6).EvcEgFsesTles ;
MveEgFsesThcg = (nop, 0.4).EvcEgFsesThcg ;
EvcEgRecles = (egleslset, r).MveEgFlesTset +
            (egleslses, r).MveEgFlesTses +
            (egleslhas, r).MveEgFlesThas ;
MveEgFlesTset = (nop, 0.6).EvcEgFlesTset ;
MveEgFlesTses = (nop, 0.6).EvcEgFlesTses ;
MveEgFlesThas = (nop, 0.6).EvcEgFlesThas ;
EvcEgRechas = (eghaslras, r).MveEgFhasTras +
            (eghaslles, r).MveEgFhasTles +
            (eghaslrbs, r).MveEgFhasTrbs +
            (eghasllws, r).MveEgFhasTlws ;
MveEgFhasTras = (nop, 1.2).EvcEgFhasTras ;
MveEgFhasTles = (nop, 0.4).EvcEgFhasTles ;
MveEgFhasTrbs = (nop, 1.2).EvcEgFhasTrbs ;
MveEgFhasTlws = (nop, 0.4).EvcEgFhasTlws ;
EvcEgReclws = (eglwslhas, r).MveEgFlwsThas +
            (eglwslsws, r).MveEgFlwsTsws +
            (eglwslswt, r).MveEgFlwsTswt ;
MveEgFlwsThas = (nop, 0.6).EvcEgFlwsThas ;
MveEgFlwsTsws = (nop, 0.6).EvcEgFlwsTsws ;
MveEgFlwsTswt = (nop, 0.6).EvcEgFlwsTswt ;
EvcEgRecsws = (egswsllws, r).MveEgFswsTlws +
            (egswsloag, r).MveEgFswsToag ;
MveEgFswsTlws = (nop, 0.6).EvcEgFswsTlws ;
MveEgFswsToag = (nop, 0.6).EvcEgFswsToag ;
EvcEgRecrbs = (egrbslhas, r).MveEgFrbsThas ;
MveEgFrbsThas = (nop, 0.8571428571428571).EvcEgFrbsThas ;
EvcEgRecoag = (egoaglsws, r).MveEgFoagTsws +
            (egoaglg, r).MveEgFoagTg +
            (egoaglhbg, r).MveEgFoagThbg +
            (egoaglhag, r).MveEgFoagThag +
            (egoaglrag, r).MveEgFoagTrag ;
MveEgFoagTsws = (nop, 1.2).EvcEgFoagTsws ;
MveEgFoagTg = (nop, 2.0).EvcEgFoagTg ;
MveEgFoagThbg = (nop, 0.3).EvcEgFoagThbg ;
MveEgFoagThag = (nop, 0.2857142857142857).EvcEgFoagThag ;
MveEgFoagTrag = (nop, 0.3).EvcEgFoagTrag ;
EvcEgRechbg = (eghbgloag, r).MveEgFhbgToag +
            (eghbglhcg, r).MveEgFhbgThcg +
            (eghbglrag, r).MveEgFhbgTrag ;
MveEgFhbgToag = (nop, 0.3).EvcEgFhbgToag ;
MveEgFhbgThcg = (nop, 0.3).EvcEgFhbgThcg ;
MveEgFhbgTrag = (nop, 0.6).EvcEgFhbgTrag ;
EvcEgRechag = (eghagloag, r).MveEgFhagToag +
            (eghaglhcg, r).MveEgFhagThcg +
            (eghaglf, r).MveEgFhagTf ;
MveEgFhagToag = (nop, 0.2857142857142857).EvcEgFhagToag ;
MveEgFhagThcg = (nop, 0.4).EvcEgFhagThcg ;
MveEgFhagTf = (nop, 0.4).EvcEgFhagTf ;
EvcEgRechcg = (eghcglses, r).MveEgFhcgTses +
            (eghcglhbg, r).MveEgFhcgThbg +
            (eghcglhag, r).MveEgFhcgThag +
            (eghcglrag, r).MveEgFhcgTrag +
            (eghcglf, r).MveEgFhcgTf ;
MveEgFhcgTses = (nop, 2.0).EvcEgFhcgTses ;
MveEgFhcgThbg = (nop, 0.4).EvcEgFhcgThbg ;
MveEgFhcgThag = (nop, 2.0).EvcEgFhcgThag ;
MveEgFhcgTrag = (nop, 2.0).EvcEgFhcgTrag ;
MveEgFhcgTf = (nop, 2.0).EvcEgFhcgTf ;
EvcEgRecrag = (egraglhbg, r).MveEgFragThbg +
            (egraglhcg, r).MveEgFragThcg +
            (egragloag, r).MveEgFragToag ;
MveEgFragThbg = (nop, 0.3333333333333333).EvcEgFragThbg ;
MveEgFragThcg = (nop, 0.4).EvcEgFragThcg ;
MveEgFragToag = (nop, 0.4).EvcEgFragToag ;
EvcEgRecf = (egflhcg, r).MveEgFfThcg +
            (egflhag, r).MveEgFfThag ;
MveEgFfThcg = (nop, 2.0).EvcEgFfThcg ;
MveEgFfThag = (nop, 2.0).EvcEgFfThag ;
EvcEfRecrat = (efratlhat, r).MveEfFratThat ;
MveEfFratThat = (nop, 0.8571428571428571).EvcEfFratThat ;
EvcEfRecrbt = (efrbtlhat, r).MveEfFrbtThat ;
MveEfFrbtThat = (nop, 0.8571428571428571).EvcEfFrbtThat ;
EvcEfRecrct = (efrctlhat, r).MveEfFrctThat ;
MveEfFrctThat = (nop, 0.8571428571428571).EvcEfFrctThat ;
EvcEfRechat = (efhatlrat, r).MveEfFhatTrat +
            (efhatlrbt, r).MveEfFhatTrbt +
            (efhatlrct, r).MveEfFhatTrct +
            (efhatllwt, r).MveEfFhatTlwt +
            (efhatllet, r).MveEfFhatTlet ;
MveEfFhatTrat = (nop, 1.2).EvcEfFhatTrat ;
MveEfFhatTrbt = (nop, 1.2).EvcEfFhatTrbt ;
MveEfFhatTrct = (nop, 1.2).EvcEfFhatTrct ;
MveEfFhatTlwt = (nop, 0.4).EvcEfFhatTlwt ;
MveEfFhatTlet = (nop, 0.4).EvcEfFhatTlet ;
EvcEfReclwt = (eflwtlhat, r).MveEfFlwtThat +
            (eflwtlswt, r).MveEfFlwtTswt ;
MveEfFlwtThat = (nop, 0.6).EvcEfFlwtThat ;
MveEfFlwtTswt = (nop, 0.6).EvcEfFlwtTswt ;
EvcEfReclet = (efletlhat, r).MveEfFletThat +
            (efletlset, r).MveEfFletTset ;
MveEfFletThat = (nop, 0.6).EvcEfFletThat ;
MveEfFletTset = (nop, 0.6).EvcEfFletTset ;
EvcEfRecset = (efsetllet, r).MveEfFsetTlet +
            (efsetlles, r).MveEfFsetTles ;
MveEfFsetTlet = (nop, 0.6).EvcEfFsetTlet ;
MveEfFsetTles = (nop, 0.6).EvcEfFsetTles ;
EvcEfRecswt = (efswtllwt, r).MveEfFswtTlwt +
            (efswtllws, r).MveEfFswtTlws ;
MveEfFswtTlwt = (nop, 0.6).EvcEfFswtTlwt ;
MveEfFswtTlws = (nop, 0.6).EvcEfFswtTlws ;
EvcEfRecras = (efraslhas, r).MveEfFrasThas ;
MveEfFrasThas = (nop, 0.8571428571428571).EvcEfFrasThas ;
EvcEfRecses = (efseslles, r).MveEfFsesTles +
            (efseslhcg, r).MveEfFsesThcg ;
MveEfFsesTles = (nop, 0.6).EvcEfFsesTles ;
MveEfFsesThcg = (nop, 0.4).EvcEfFsesThcg ;
EvcEfRecles = (efleslset, r).MveEfFlesTset +
            (efleslses, r).MveEfFlesTses +
            (efleslhas, r).MveEfFlesThas ;
MveEfFlesTset = (nop, 0.6).EvcEfFlesTset ;
MveEfFlesTses = (nop, 0.6).EvcEfFlesTses ;
MveEfFlesThas = (nop, 0.6).EvcEfFlesThas ;
EvcEfRechas = (efhaslras, r).MveEfFhasTras +
            (efhaslles, r).MveEfFhasTles +
            (efhaslrbs, r).MveEfFhasTrbs +
            (efhasllws, r).MveEfFhasTlws ;
MveEfFhasTras = (nop, 1.2).EvcEfFhasTras ;
MveEfFhasTles = (nop, 0.4).EvcEfFhasTles ;
MveEfFhasTrbs = (nop, 1.2).EvcEfFhasTrbs ;
MveEfFhasTlws = (nop, 0.4).EvcEfFhasTlws ;
EvcEfReclws = (eflwslhas, r).MveEfFlwsThas +
            (eflwslsws, r).MveEfFlwsTsws +
            (eflwslswt, r).MveEfFlwsTswt ;
MveEfFlwsThas = (nop, 0.6).EvcEfFlwsThas ;
MveEfFlwsTsws = (nop, 0.6).EvcEfFlwsTsws ;
MveEfFlwsTswt = (nop, 0.6).EvcEfFlwsTswt ;
EvcEfRecsws = (efswsllws, r).MveEfFswsTlws +
            (efswsloag, r).MveEfFswsToag ;
MveEfFswsTlws = (nop, 0.6).EvcEfFswsTlws ;
MveEfFswsToag = (nop, 0.6).EvcEfFswsToag ;
EvcEfRecrbs = (efrbslhas, r).MveEfFrbsThas ;
MveEfFrbsThas = (nop, 0.8571428571428571).EvcEfFrbsThas ;
EvcEfRecoag = (efoaglsws, r).MveEfFoagTsws +
            (efoaglg, r).MveEfFoagTg +
            (efoaglhbg, r).MveEfFoagThbg +
            (efoaglhag, r).MveEfFoagThag +
            (efoaglrag, r).MveEfFoagTrag ;
MveEfFoagTsws = (nop, 1.2).EvcEfFoagTsws ;
MveEfFoagTg = (nop, 2.0).EvcEfFoagTg ;
MveEfFoagThbg = (nop, 0.3).EvcEfFoagThbg ;
MveEfFoagThag = (nop, 0.2857142857142857).EvcEfFoagThag ;
MveEfFoagTrag = (nop, 0.3).EvcEfFoagTrag ;
EvcEfRechbg = (efhbgloag, r).MveEfFhbgToag +
            (efhbglhcg, r).MveEfFhbgThcg +
            (efhbglrag, r).MveEfFhbgTrag ;
MveEfFhbgToag = (nop, 0.3).EvcEfFhbgToag ;
MveEfFhbgThcg = (nop, 0.3).EvcEfFhbgThcg ;
MveEfFhbgTrag = (nop, 0.6).EvcEfFhbgTrag ;
EvcEfRechag = (efhagloag, r).MveEfFhagToag +
            (efhaglhcg, r).MveEfFhagThcg +
            (efhaglf, r).MveEfFhagTf ;
MveEfFhagToag = (nop, 0.2857142857142857).EvcEfFhagToag ;
MveEfFhagThcg = (nop, 0.4).EvcEfFhagThcg ;
MveEfFhagTf = (nop, 0.4).EvcEfFhagTf ;
EvcEfRechcg = (efhcglses, r).MveEfFhcgTses +
            (efhcglhbg, r).MveEfFhcgThbg +
            (efhcglhag, r).MveEfFhcgThag +
            (efhcglrag, r).MveEfFhcgTrag +
            (efhcglf, r).MveEfFhcgTf ;
MveEfFhcgTses = (nop, 2.0).EvcEfFhcgTses ;
MveEfFhcgThbg = (nop, 0.4).EvcEfFhcgThbg ;
MveEfFhcgThag = (nop, 2.0).EvcEfFhcgThag ;
MveEfFhcgTrag = (nop, 2.0).EvcEfFhcgTrag ;
MveEfFhcgTf = (nop, 2.0).EvcEfFhcgTf ;
EvcEfRecrag = (efraglhbg, r).MveEfFragThbg +
            (efraglhcg, r).MveEfFragThcg +
            (efragloag, r).MveEfFragToag ;
MveEfFragThbg = (nop, 0.3333333333333333).EvcEfFragThbg ;
MveEfFragThcg = (nop, 0.4).EvcEfFragThcg ;
MveEfFragToag = (nop, 0.4).EvcEfFragToag ;
EvcEfRecg = (efgloag, r).MveEfFgToag ;
MveEfFgToag = (nop, 2.0).EvcEfFgToag ;


DUrathat = (rathat, udr).DUrathat ;
DUrbthat = (rbthat, udr).DUrbthat ;
DUrcthat = (rcthat, udr).DUrcthat ;
DUhatlwt = (hatlwt, udr).DUhatlwt ;
DUhatlet = (hatlet, udr).DUhatlet ;
DUlwtswt = (lwtswt, udr).DUlwtswt ;
DUletset = (letset, udr).DUletset ;
DUsetles = (setles, udr).DUsetles ;
DUswtlws = (swtlws, udr).DUswtlws ;
DUlesses = (lesses, udr).DUlesses ;
DUleshas = (leshas, udr).DUleshas ;
DUhasras = (hasras, udr).DUhasras ;
DUhasrbs = (hasrbs, udr).DUhasrbs ;
DUhaslws = (haslws, udr).DUhaslws ;
DUlwssws = (lwssws, udr).DUlwssws ;
DUseshcg = (seshcg, udr).DUseshcg ;
DUswsoag = (swsoag, udr).DUswsoag ;
DUoagg = (oagg, udr).DUoagg ;
DUoaghbg = (oaghbg, udr).DUoaghbg ;
DUoaghag = (oaghag, udr).DUoaghag ;
DUoagrag = (oagrag, udr).DUoagrag ;
DUhbghcg = (hbghcg, udr).DUhbghcg ;
DUhbgrag = (hbgrag, udr).DUhbgrag ;
DUhaghcg = (haghcg, udr).DUhaghcg ;
DUhcgrag = (hcgrag, udr).DUhcgrag ;
DUhcgf = (hcgf, udr).DUhcgf ;
DUhagf = (hagf, udr).DUhagf ;


RqHLrat = (lrateg, a).RqHLratRespEg +
           (lratef, a).RqHLratRespEf ;
           

RqHLratRespEg = (egratlhat, r).RqHLrat ;
RqHLratRespEf = (efratlhat, r).RqHLrat ;


RqHLrbt = (lrbteg, a).RqHLrbtRespEg +
           (lrbtef, a).RqHLrbtRespEf ;
           

RqHLrbtRespEg = (egrbtlhat, r).RqHLrbt ;
RqHLrbtRespEf = (efrbtlhat, r).RqHLrbt ;


RqHLrct = (lrcteg, a).RqHLrctRespEg +
           (lrctef, a).RqHLrctRespEf ;
           

RqHLrctRespEg = (egrctlhat, r).RqHLrct ;
RqHLrctRespEf = (efrctlhat, r).RqHLrct ;


RqHLhat = (lhateg, a).RqHLhatRespEg +
           (lhatef, a).RqHLhatRespEf ;
           

RqHLhatRespEg = (eghatllwt, r).RqHLhat ;
RqHLhatRespEf = (efhatllet, r).RqHLhat ;


RqHLlwt = (llwteg, a).RqHLlwtRespEg +
           (llwtef, a).RqHLlwtRespEf ;
           

RqHLlwtRespEg = (eglwtlswt, r).RqHLlwt ;
RqHLlwtRespEf = (eflwtlhat, r).RqHLlwt ;


RqHLlet = (lleteg, a).RqHLletRespEg +
           (lletef, a).RqHLletRespEf ;
           

RqHLletRespEg = (egletlhat, r).RqHLlet ;
RqHLletRespEf = (efletlset, r).RqHLlet ;


RqHLset = (lseteg, a).RqHLsetRespEg +
           (lsetef, a).RqHLsetRespEf ;
           

RqHLsetRespEg = (egsetlles, r).RqHLset ;
RqHLsetRespEf = (efsetlles, r).RqHLset ;


RqHLswt = (lswteg, a).RqHLswtRespEg +
           (lswtef, a).RqHLswtRespEf ;
           

RqHLswtRespEg = (egswtllws, r).RqHLswt ;
RqHLswtRespEf = (efswtllws, r).RqHLswt ;


RqHLras = (lraseg, a).RqHLrasRespEg +
           (lrasef, a).RqHLrasRespEf ;
           

RqHLrasRespEg = (egraslhas, r).RqHLras ;
RqHLrasRespEf = (efraslhas, r).RqHLras ;


RqHLses = (lseseg, a).RqHLsesRespEg +
           (lsesef, a).RqHLsesRespEf ;
           

RqHLsesRespEg = (egseslhcg, r).RqHLses ;
RqHLsesRespEf = (efseslhcg, r).RqHLses ;


RqHLles = (lleseg, a).RqHLlesRespEg +
           (llesef, a).RqHLlesRespEf ;
           

RqHLlesRespEg = (egleslhas, r).RqHLles ;
RqHLlesRespEf = (efleslses, r).RqHLles ;


RqHLhas = (lhaseg, a).RqHLhasRespEg +
           (lhasef, a).RqHLhasRespEf ;
           

RqHLhasRespEg = (eghasllws, r).RqHLhas ;
RqHLhasRespEf = (efhaslles, r).RqHLhas ;


RqHLlws = (llwseg, a).RqHLlwsRespEg +
           (llwsef, a).RqHLlwsRespEf ;
           

RqHLlwsRespEg = (eglwslsws, r).RqHLlws ;
RqHLlwsRespEf = (eflwslhas, r).RqHLlws ;


RqHLsws = (lswseg, a).RqHLswsRespEg +
           (lswsef, a).RqHLswsRespEf ;
           

RqHLswsRespEg = (egswsloag, r).RqHLsws ;
RqHLswsRespEf = (efswsloag, r).RqHLsws ;


RqHLrbs = (lrbseg, a).RqHLrbsRespEg +
           (lrbsef, a).RqHLrbsRespEf ;
           

RqHLrbsRespEg = (egrbslhas, r).RqHLrbs ;
RqHLrbsRespEf = (efrbslhas, r).RqHLrbs ;


RqHLoag = (loageg, a).RqHLoagRespEg +
           (loagef, a).RqHLoagRespEf ;
           

RqHLoagRespEg = (egoaglg, r).RqHLoag ;
RqHLoagRespEf = (efoaglrag, r).RqHLoag ;


RqHLhbg = (lhbgeg, a).RqHLhbgRespEg +
           (lhbgef, a).RqHLhbgRespEf ;
           

RqHLhbgRespEg = (eghbgloag, r).RqHLhbg ;
RqHLhbgRespEf = (efhbglhcg, r).RqHLhbg ;


RqHLhag = (lhageg, a).RqHLhagRespEg +
           (lhagef, a).RqHLhagRespEf ;
           

RqHLhagRespEg = (eghagloag, r).RqHLhag ;
RqHLhagRespEf = (efhaglf, r).RqHLhag ;


RqHLhcg = (lhcgeg, a).RqHLhcgRespEg +
           (lhcgef, a).RqHLhcgRespEf ;
           

RqHLhcgRespEg = (eghcglrag, r).RqHLhcg ;
RqHLhcgRespEf = (efhcglf, r).RqHLhcg ;


RqHLrag = (lrageg, a).RqHLragRespEg +
           (lragef, a).RqHLragRespEf ;
           

RqHLragRespEg = (egragloag, r).RqHLrag ;
RqHLragRespEf = (efraglhcg, r).RqHLrag ;


RqHLf = (lfeg, a).RqHLfRespEg +
         (lfef, a).RqHLf ;
         

RqHLfRespEg = (egflhag, r).RqHLf ;


RqHLg = (lgeg, a).RqHLg +
         (lgef, a).RqHLgRespEf ;
         

RqHLgRespEf = (efgloag, r).RqHLg ;




PlaceFreeLrat = (lratop,s).PlaceFullLrat;
PlaceFullLrat = (lratfp,s).PlaceFreeLrat;

PlaceFreeLrbt = (lrbtop,s).PlaceFullLrbt;
PlaceFullLrbt = (lrbtfp,s).PlaceFreeLrbt;

PlaceFreeLrct = (lrctop,s).PlaceFullLrct;
PlaceFullLrct = (lrctfp,s).PlaceFreeLrct;

PlaceFreeLhat = (lhatop,s).PlaceFullLhat;
PlaceFullLhat = (lhatfp,s).PlaceFreeLhat;

PlaceFreeLlwt = (llwtop,s).PlaceFullLlwt;
PlaceFullLlwt = (llwtfp,s).PlaceFreeLlwt;

PlaceFreeLlet = (lletop,s).PlaceFullLlet;
PlaceFullLlet = (lletfp,s).PlaceFreeLlet;

PlaceFreeLset = (lsetop,s).PlaceFullLset;
PlaceFullLset = (lsetfp,s).PlaceFreeLset;

PlaceFreeLswt = (lswtop,s).PlaceFullLswt;
PlaceFullLswt = (lswtfp,s).PlaceFreeLswt;

PlaceFreeLras = (lrasop,s).PlaceFullLras;
PlaceFullLras = (lrasfp,s).PlaceFreeLras;

PlaceFreeLses = (lsesop,s).PlaceFullLses;
PlaceFullLses = (lsesfp,s).PlaceFreeLses;

PlaceFreeLles = (llesop,s).PlaceFullLles;
PlaceFullLles = (llesfp,s).PlaceFreeLles;

PlaceFreeLhas = (lhasop,s).PlaceFullLhas;
PlaceFullLhas = (lhasfp,s).PlaceFreeLhas;

PlaceFreeLlws = (llwsop,s).PlaceFullLlws;
PlaceFullLlws = (llwsfp,s).PlaceFreeLlws;

PlaceFreeLsws = (lswsop,s).PlaceFullLsws;
PlaceFullLsws = (lswsfp,s).PlaceFreeLsws;

PlaceFreeLrbs = (lrbsop,s).PlaceFullLrbs;
PlaceFullLrbs = (lrbsfp,s).PlaceFreeLrbs;

PlaceFreeLoag = (loagop,s).PlaceFullLoag;
PlaceFullLoag = (loagfp,s).PlaceFreeLoag;

PlaceFreeLhbg = (lhbgop,s).PlaceFullLhbg;
PlaceFullLhbg = (lhbgfp,s).PlaceFreeLhbg;

PlaceFreeLhag = (lhagop,s).PlaceFullLhag;
PlaceFullLhag = (lhagfp,s).PlaceFreeLhag;

PlaceFreeLhcg = (lhcgop,s).PlaceFullLhcg;
PlaceFullLhcg = (lhcgfp,s).PlaceFreeLhcg;

PlaceFreeLrag = (lragop,s).PlaceFullLrag;
PlaceFullLrag = (lragfp,s).PlaceFreeLrag;

PlaceFreeLf = (lfop,s).PlaceFullLf;
PlaceFullLf = (lffp,s).PlaceFreeLf;

PlaceFreeLg = (lgop,s).PlaceFullLg;
PlaceFullLg = (lgfp,s).PlaceFreeLg;

(EvcEgoprat[1800]<>
EvcEfoprat[1800]<>
EvcEgoprbt[1600]<>
EvcEfoprct[1800]<>
EvcEgoprag[3600]<>
EvcEfoprag[3600]<>
EvcEfopras[1800]<>
EvcEgopras[1800]<>
EvcEfoprbs[1700]<>
EvcEgoprbs[1700])
<lrateg,
lrbteg,
lrcteg,
lhateg,
llwteg,
lleteg,
lseteg,
lswteg,
lraseg,
lseseg,
lleseg,
lhaseg,
llwseg,
lswseg,
lrbseg,
loageg,
lhbgeg,
lhageg,
lhcgeg,
lrageg,
lfeg,
lgeg,
lratef,
lrbtef,
lrctef,
lhatef,
llwtef,
lletef,
lsetef,
lswtef,
lrasef,
lsesef,
llesef,
lhasef,
llwsef,
lswsef,
lrbsef,
loagef,
lhbgef,
lhagef,
lhcgef,
lragef,
lfef,
lgef,
egratlhat,
egrbtlhat,
egrctlhat,
eghatlrat,
eghatlrbt,
eghatlrct,
eghatllwt,
eghatllet,
eglwtlhat,
eglwtlswt,
egletlhat,
egletlset,
egsetllet,
egsetlles,
egswtllwt,
egswtllws,
egraslhas,
egseslles,
egseslhcg,
egleslset,
egleslses,
egleslhas,
eghaslras,
eghaslles,
eghaslrbs,
eghasllws,
eglwslhas,
eglwslsws,
eglwslswt,
egswsllws,
egswsloag,
egrbslhas,
egoaglsws,
egoaglg,
egoaglhbg,
egoaglhag,
egoaglrag,
eghbgloag,
eghbglhcg,
eghbglrag,
eghagloag,
eghaglhcg,
eghaglf,
eghcglses,
eghcglhbg,
eghcglhag,
eghcglrag,
eghcglf,
egraglhbg,
egraglhcg,
egragloag,
egflhcg,
egflhag,
efratlhat,
efrbtlhat,
efrctlhat,
efhatlrat,
efhatlrbt,
efhatlrct,
efhatllwt,
efhatllet,
eflwtlhat,
eflwtlswt,
efletlhat,
efletlset,
efsetllet,
efsetlles,
efswtllwt,
efswtllws,
efraslhas,
efseslles,
efseslhcg,
efleslset,
efleslses,
efleslhas,
efhaslras,
efhaslles,
efhaslrbs,
efhasllws,
eflwslhas,
eflwslsws,
eflwslswt,
efswsllws,
efswsloag,
efrbslhas,
efoaglsws,
efoaglg,
efoaglhbg,
efoaglhag,
efoaglrag,
efhbgloag,
efhbglhcg,
efhbglrag,
efhagloag,
efhaglhcg,
efhaglf,
efhcglses,
efhcglhbg,
efhcglhag,
efhcglrag,
efhcglf,
efraglhbg,
efraglhcg,
efragloag,
efgloag,
rathat,
rbthat,
rcthat,
hatlwt,
hatlet,
lwtswt,
letset,
setles,
swtlws,
lesses,
leshas,
hasras,
hasrbs,
haslws,
lwssws,
seshcg,
swsoag,
oagg,
oaghbg,
oaghag,
oagrag,
hbghcg,
hbgrag,
haghcg,
hcgrag,
hcgf,
hagf,
lratop,
lratfp,
lrbtop,
lrbtfp,
lrctop,
lrctfp,
lhatop,
lhatfp,
llwtop,
llwtfp,
lletop,
lletfp,
lsetop,
lsetfp,
lswtop,
lswtfp,
lrasop,
lrasfp,
lsesop,
lsesfp,
llesop,
llesfp,
lhasop,
lhasfp,
llwsop,
llwsfp,
lswsop,
lswsfp,
lrbsop,
lrbsfp,
loagop,
loagfp,
lhbgop,
lhbgfp,
lhagop,
lhagfp,
lhcgop,
lhcgfp,
lragop,
lragfp,
lfop,
lffp,
lgop,
lgfp
>
(DUrathat[30]<>
DUrbthat[20]<>
DUrcthat[20]<>
DUhatlwt[10]<>
DUhatlet[10]<>
DUlwtswt[10]<>
DUletset[10]<>
DUsetles[10]<>
DUswtlws[10]<>
DUlesses[10]<>
DUleshas[10]<>
DUhasras[30]<>
DUhasrbs[30]<>
DUhaslws[10]<>
DUlwssws[10]<>
DUseshcg[10]<>
DUswsoag[10]<>
DUoagg[20]<>
DUoaghbg[10]<>
DUoaghag[10]<>
DUoagrag[20]<>
DUhbghcg[10]<>
DUhbgrag[20]<>
DUhaghcg[10]<>
DUhcgrag[10]<>
DUhcgf[10]<>
DUhagf[10]<>
RqHLrat[40]<>
RqHLrbt[40]<>
RqHLrct[40]<>
RqHLhat[40]<>
RqHLlwt[40]<>
RqHLlet[40]<>
RqHLset[40]<>
RqHLswt[40]<>
RqHLras[40]<>
RqHLses[40]<>
RqHLles[40]<>
RqHLhas[40]<>
RqHLlws[40]<>
RqHLsws[40]<>
RqHLrbs[40]<>
RqHLoag[40]<>
RqHLhbg[40]<>
RqHLhag[40]<>
RqHLhcg[40]<>
RqHLrag[40]<>
RqHLf[40]<>
RqHLg[40]<>
PlaceFullLrat[3600]<>
PlaceFullLrbt[1600]<>
PlaceFullLrct[1800]<>
PlaceFreeLhat[1330]<>
PlaceFreeLlwt[250]<>
PlaceFreeLlet[160]<>
PlaceFreeLset[130]<>
PlaceFreeLswt[220]<>
PlaceFullLras[3600]<>
PlaceFreeLses[230]<>
PlaceFreeLles[160]<>
PlaceFreeLhas[1330]<>
PlaceFreeLlws[250]<>
PlaceFreeLsws[290]<>
PlaceFullLrbs[3400]<>
PlaceFreeLoag[1240]<>
PlaceFreeLhbg[1170]<>
PlaceFreeLhag[660]<>
PlaceFreeLhcg[190]<>
PlaceFullLrag[7200]<>
PlaceFreeLf[220]<>
PlaceFreeLg[130])