- : unit = ()
h : heuristic = <heuristic>
- : unit = ()
APPLY CRITERIA (Marked dependency pairs)

TRS termination of:
[1] or(T,T) -> T
[2] or(F,T) -> T
[3] or(T,F) -> T
[4] or(F,F) -> F
[5] and(T,B) -> B
[6] and(B,T) -> B
[7] and(F,B) -> F
[8] and(B,F) -> F
[9] imp(T,B) -> B
[10] imp(F,B) -> T
[11] not(T) -> F
[12] not(F) -> T
[13] if(T,B1,B2) -> B1
[14] if(F,B1,B2) -> B2
[15] eq(T,T) -> T
[16] eq(F,F) -> T
[17] eq(T,F) -> F
[18] eq(F,T) -> F
[19] eqt(nil,undefined) -> F
[20] eqt(nil,pid(N2)) -> F
[21] eqt(nil,int(N2)) -> F
[22] eqt(nil,cons(H2,T2)) -> F
[23] eqt(nil,tuple(H2,T2)) -> F
[24] eqt(nil,tuplenil(H2)) -> F
[25] eqt(a,nil) -> F
[26] eqt(a,a) -> T
[27] eqt(a,excl) -> F
[28] eqt(a,false) -> F
[29] eqt(a,lock) -> F
[30] eqt(a,locker) -> F
[31] eqt(a,mcrlrecord) -> F
[32] eqt(a,ok) -> F
[33] eqt(a,pending) -> F
[34] eqt(a,release) -> F
[35] eqt(a,request) -> F
[36] eqt(a,resource) -> F
[37] eqt(a,tag) -> F
[38] eqt(a,true) -> F
[39] eqt(a,undefined) -> F
[40] eqt(a,pid(N2)) -> F
[41] eqt(a,int(N2)) -> F
[42] eqt(a,cons(H2,T2)) -> F
[43] eqt(a,tuple(H2,T2)) -> F
[44] eqt(a,tuplenil(H2)) -> F
[45] eqt(excl,nil) -> F
[46] eqt(excl,a) -> F
[47] eqt(excl,excl) -> T
[48] eqt(excl,false) -> F
[49] eqt(excl,lock) -> F
[50] eqt(excl,locker) -> F
[51] eqt(excl,mcrlrecord) -> F
[52] eqt(excl,ok) -> F
[53] eqt(excl,pending) -> F
[54] eqt(excl,release) -> F
[55] eqt(excl,request) -> F
[56] eqt(excl,resource) -> F
[57] eqt(excl,tag) -> F
[58] eqt(excl,true) -> F
[59] eqt(excl,undefined) -> F
[60] eqt(excl,pid(N2)) -> F
[61] eqt(excl,eqt(false,int(N2))) -> F
[62] eqt(false,cons(H2,T2)) -> F
[63] eqt(false,tuple(H2,T2)) -> F
[64] eqt(false,tuplenil(H2)) -> F
[65] eqt(lock,nil) -> F
[66] eqt(lock,a) -> F
[67] eqt(lock,excl) -> F
[68] eqt(lock,false) -> F
[69] eqt(lock,lock) -> T
[70] eqt(lock,locker) -> F
[71] eqt(lock,mcrlrecord) -> F
[72] eqt(lock,ok) -> F
[73] eqt(lock,pending) -> F
[74] eqt(lock,release) -> F
[75] eqt(lock,request) -> F
[76] eqt(lock,resource) -> F
[77] eqt(lock,tag) -> F
[78] eqt(lock,true) -> F
[79] eqt(lock,undefined) -> F
[80] eqt(lock,pid(N2)) -> F
[81] eqt(lock,int(N2)) -> F
[82] eqt(lock,cons(H2,T2)) -> F
[83] eqt(lock,tuple(H2,T2)) -> F
[84] eqt(lock,tuplenil(H2)) -> F
[85] eqt(locker,nil) -> F
[86] eqt(locker,a) -> F
[87] eqt(locker,excl) -> F
[88] eqt(locker,false) -> F
[89] eqt(locker,lock) -> F
[90] eqt(locker,locker) -> T
[91] eqt(locker,mcrlrecord) -> F
[92] eqt(locker,ok) -> F
[93] eqt(locker,pending) -> F
[94] eqt(locker,release) -> F
[95] eqt(locker,request) -> F
[96] eqt(locker,resource) -> F
[97] eqt(locker,tag) -> F
[98] eqt(locker,true) -> F
[99] eqt(locker,undefined) -> F
[100] eqt(locker,pid(N2)) -> F
[101] eqt(locker,int(N2)) -> F
[102] eqt(locker,cons(H2,T2)) -> F
[103] eqt(locker,tuple(H2,T2)) -> F
[104] eqt(locker,tuplenil(H2)) -> F
[105] eqt(mcrlrecord,nil) -> F
[106] eqt(mcrlrecord,a) -> F
[107] eqt(mcrlrecord,excl) -> F
[108] eqt(mcrlrecord,false) -> F
[109] eqt(mcrlrecord,lock) -> F
[110] eqt(mcrlrecord,locker) -> F
[111] eqt(mcrlrecord,mcrlrecord) -> T
[112] eqt(mcrlrecord,ok) -> F
[113] eqt(mcrlrecord,pending) -> F
[114] eqt(mcrlrecord,release) -> F
[115] eqt(mcrlrecord,request) -> F
[116] eqt(mcrlrecord,resource) -> F
[117] eqt(ok,resource) -> F
[118] eqt(ok,tag) -> F
[119] eqt(ok,true) -> F
[120] eqt(ok,undefined) -> F
[121] eqt(ok,pid(N2)) -> F
[122] eqt(ok,int(N2)) -> F
[123] eqt(ok,cons(H2,T2)) -> F
[124] eqt(ok,tuple(H2,T2)) -> F
[125] eqt(ok,tuplenil(H2)) -> F
[126] eqt(pending,nil) -> F
[127] eqt(pending,a) -> F
[128] eqt(pending,excl) -> F
[129] eqt(pending,false) -> F
[130] eqt(pending,lock) -> F
[131] eqt(pending,locker) -> F
[132] eqt(pending,mcrlrecord) -> F
[133] eqt(pending,ok) -> F
[134] eqt(pending,pending) -> T
[135] eqt(pending,release) -> F
[136] eqt(pending,request) -> F
[137] eqt(pending,resource) -> F
[138] eqt(pending,tag) -> F
[139] eqt(pending,true) -> F
[140] eqt(pending,undefined) -> F
[141] eqt(pending,pid(N2)) -> F
[142] eqt(pending,int(N2)) -> F
[143] eqt(pending,cons(H2,T2)) -> F
[144] eqt(pending,tuple(H2,T2)) -> F
[145] eqt(pending,tuplenil(H2)) -> F
[146] eqt(release,nil) -> F
[147] eqt(release,a) -> F
[148] eqt(release,excl) -> F
[149] eqt(release,false) -> F
[150] eqt(release,lock) -> F
[151] eqt(release,locker) -> F
[152] eqt(release,mcrlrecord) -> F
[153] eqt(release,ok) -> F
[154] eqt(request,mcrlrecord) -> F
[155] eqt(request,ok) -> F
[156] eqt(request,pending) -> F
[157] eqt(request,release) -> F
[158] eqt(request,request) -> T
[159] eqt(request,resource) -> F
[160] eqt(request,tag) -> F
[161] eqt(request,true) -> F
[162] eqt(request,undefined) -> F
[163] eqt(request,pid(N2)) -> F
[164] eqt(request,int(N2)) -> F
[165] eqt(request,cons(H2,T2)) -> F
[166] eqt(request,tuple(H2,T2)) -> F
[167] eqt(request,tuplenil(H2)) -> F
[168] eqt(resource,nil) -> F
[169] eqt(resource,a) -> F
[170] eqt(resource,excl) -> F
[171] eqt(resource,false) -> F
[172] eqt(resource,lock) -> F
[173] eqt(resource,locker) -> F
[174] eqt(resource,mcrlrecord) -> F
[175] eqt(resource,ok) -> F
[176] eqt(resource,pending) -> F
[177] eqt(resource,release) -> F
[178] eqt(resource,request) -> F
[179] eqt(resource,resource) -> T
[180] eqt(resource,tag) -> F
[181] eqt(resource,true) -> F
[182] eqt(resource,undefined) -> F
[183] eqt(resource,pid(N2)) -> F
[184] eqt(resource,int(N2)) -> F
[185] eqt(resource,cons(H2,T2)) -> F
[186] eqt(resource,tuple(H2,T2)) -> F
[187] eqt(resource,tuplenil(H2)) -> F
[188] eqt(tag,nil) -> F
[189] eqt(tag,a) -> F
[190] eqt(tag,excl) -> F
[191] eqt(tag,false) -> F
[192] eqt(tag,lock) -> F
[193] eqt(tag,locker) -> F
[194] eqt(tag,mcrlrecord) -> F
[195] eqt(tag,ok) -> F
[196] eqt(tag,pending) -> F
[197] eqt(tag,release) -> F
[198] eqt(tag,request) -> F
[199] eqt(tag,resource) -> F
[200] eqt(tag,tag) -> T
[201] eqt(tag,true) -> F
[202] eqt(tag,undefined) -> F
[203] eqt(tag,pid(N2)) -> F
[204] eqt(tag,int(N2)) -> F
[205] eqt(tag,cons(H2,T2)) -> F
[206] eqt(tag,tuple(H2,T2)) -> F
[207] eqt(tag,tuplenil(H2)) -> F
[208] eqt(true,nil) -> F
[209] eqt(true,a) -> F
[210] eqt(true,excl) -> F
[211] eqt(true,false) -> F
[212] eqt(true,lock) -> F
[213] eqt(true,locker) -> F
[214] eqt(true,mcrlrecord) -> F
[215] eqt(true,ok) -> F
[216] eqt(true,pending) -> F
[217] eqt(true,release) -> F
[218] eqt(true,request) -> F
[219] eqt(true,resource) -> F
[220] eqt(true,tag) -> F
[221] eqt(true,true) -> T
[222] eqt(true,undefined) -> F
[223] eqt(true,pid(N2)) -> F
[224] eqt(true,int(N2)) -> F
[225] eqt(true,cons(H2,T2)) -> F
[226] eqt(true,tuple(H2,T2)) -> F
[227] eqt(true,tuplenil(H2)) -> F
[228] eqt(undefined,nil) -> F
[229] eqt(undefined,a) -> F
[230] eqt(undefined,tuplenil(H2)) -> F
[231] eqt(pid(N1),nil) -> F
[232] eqt(pid(N1),a) -> F
[233] eqt(pid(N1),excl) -> F
[234] eqt(pid(N1),false) -> F
[235] eqt(pid(N1),lock) -> F
[236] eqt(pid(N1),locker) -> F
[237] eqt(pid(N1),mcrlrecord) -> F
[238] eqt(pid(N1),ok) -> F
[239] eqt(pid(N1),pending) -> F
[240] eqt(pid(N1),release) -> F
[241] eqt(pid(N1),request) -> F
[242] eqt(pid(N1),resource) -> F
[243] eqt(pid(N1),tag) -> F
[244] eqt(pid(N1),true) -> F
[245] eqt(pid(N1),undefined) -> F
[246] eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
[247] eqt(pid(N1),int(N2)) -> F
[248] eqt(pid(N1),cons(H2,T2)) -> F
[249] eqt(pid(N1),tuple(H2,T2)) -> F
[250] eqt(pid(N1),tuplenil(H2)) -> F
[251] eqt(int(N1),nil) -> F
[252] eqt(int(N1),a) -> F
[253] eqt(int(N1),excl) -> F
[254] eqt(int(N1),false) -> F
[255] eqt(int(N1),lock) -> F
[256] eqt(int(N1),locker) -> F
[257] eqt(int(N1),mcrlrecord) -> F
[258] eqt(int(N1),ok) -> F
[259] eqt(int(N1),pending) -> F
[260] eqt(int(N1),release) -> F
[261] eqt(int(N1),request) -> F
[262] eqt(int(N1),resource) -> F
[263] eqt(int(N1),tag) -> F
[264] eqt(int(N1),true) -> F
[265] eqt(int(N1),undefined) -> F
[266] eqt(cons(H1,T1),resource) -> F
[267] eqt(cons(H1,T1),tag) -> F
[268] eqt(cons(H1,T1),true) -> F
[269] eqt(cons(H1,T1),undefined) -> F
[270] eqt(cons(H1,T1),pid(N2)) -> F
[271] eqt(cons(H1,T1),int(N2)) -> F
[272] eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
[273] eqt(cons(H1,T1),tuple(H2,T2)) -> F
[274] eqt(cons(H1,T1),tuplenil(H2)) -> F
[275] eqt(tuple(H1,T1),nil) -> F
[276] eqt(tuple(H1,T1),a) -> F
[277] eqt(tuple(H1,T1),excl) -> F
[278] eqt(tuple(H1,T1),false) -> F
[279] eqt(tuple(H1,T1),lock) -> F
[280] eqt(tuple(H1,T1),locker) -> F
[281] eqt(tuple(H1,T1),mcrlrecord) -> F
[282] eqt(tuple(H1,T1),ok) -> F
[283] eqt(tuple(H1,T1),pending) -> F
[284] eqt(tuple(H1,T1),release) -> F
[285] eqt(tuple(H1,T1),request) -> F
[286] eqt(tuple(H1,T1),resource) -> F
[287] eqt(tuple(H1,T1),tag) -> F
[288] eqt(tuple(H1,T1),true) -> F
[289] eqt(tuple(H1,T1),undefined) -> F
[290] eqt(tuple(H1,T1),pid(N2)) -> F
[291] eqt(tuple(H1,T1),int(N2)) -> F
[292] eqt(tuple(H1,T1),cons(H2,T2)) -> F
[293] eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
[294] eqt(tuple(H1,T1),tuplenil(H2)) -> F
[295] eqt(tuplenil(H1),nil) -> F
[296] eqt(tuplenil(H1),a) -> F
[297] eqt(tuplenil(H1),excl) -> F
[298] eqt(tuplenil(H1),false) -> F
[299] eqt(tuplenil(H1),lock) -> F
[300] eqt(tuplenil(H1),locker) -> F
[301] eqt(tuplenil(H1),mcrlrecord) -> F
[302] eqt(tuplenil(H1),ok) -> F
[303] eqt(tuplenil(H1),pending) -> F
[304] eqt(tuplenil(H1),release) -> F
[305] eqt(tuplenil(H1),request) -> F
[306] eqt(tuplenil(H1),resource) -> F
[307] eqt(tuplenil(H1),tag) -> F
[308] eqt(tuplenil(H1),true) -> F
[309] eqt(tuplenil(H1),undefined) -> F
[310] eqt(tuplenil(H1),pid(N2)) -> F
[311] eqt(tuplenil(H1),int(N2)) -> F
[312] eqt(tuplenil(H1),cons(H2,T2)) -> F
[313] eqt(tuplenil(H1),tuple(H2,T2)) -> F
[314] eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
[315] element(int(s(0)),tuplenil(T1)) -> T1
[316] element(int(s(0)),tuple(T1,T2)) -> T1
[317] element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
[318] record_new(lock) ->
 tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil)))))
[319] record_extract(tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),lock,
       resource) ->
 tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
[320] record_update(tuple(mcrlrecord,
                     tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),lock,
       pending,NewF) ->
 tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF)))))
[321] record_updates(Record,Name,nil) -> Record
[322] record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) ->
 record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
[323] locker2_map_promote_pending(nil,Pending) -> nil
[324] locker2_map_promote_pending(cons(Lock,Locks),Pending) ->
 cons(locker2_promote_pending(Lock,Pending),
  locker2_map_promote_pending(Locks,Pending))
[325] locker2_map_claim_lock(nil,Resources,Client) -> nil
[326] locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) ->
 cons(locker2_claim_lock(Lock,Resources,Client),
  locker2_map_claim_lock(Locks,Resources,Client))
[327] locker2_map_add_pending(nil,Resources,Client) -> nil
[328] locker2_promote_pending(Lock,Client) ->
 case0(Client,Lock,record_extract(Lock,lock,pending))
[329] case0(Client,Lock,cons(Client,Pendings)) ->
 record_updates(Lock,lock,
  cons(tuple(excl,tuplenil(Client)),
   cons(tuple(pending,tuplenil(Pendings)),nil)))
[330] case0(Client,Lock,MCRLFree0) -> Lock
[331] locker2_remove_pending(Lock,Client) ->
 record_updates(Lock,lock,
  cons(tuple(pending,
        tuplenil(subtract(record_extract(Lock,lock,pending),cons(Client,nil)))),
   nil))
[332] locker2_add_pending(Lock,Resources,Client) ->
 case1(Client,Resources,Lock,
  member(record_extract(Lock,lock,resource),Resources))
[333] case1(Client,Resources,Lock,true) ->
 record_updates(Lock,lock,
  cons(tuple(pending,
        tuplenil(append(record_extract(Lock,lock,pending),cons(Client,nil)))),
   nil))
[334] case1(Client,Resources,Lock,false) -> Lock
[335] locker2_release_lock(Lock,Client) ->
 case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock,excl)))
[336] case2(Client,Lock,true) ->
 record_updates(Lock,lock,cons(tuple(excllock,excl),nil))
[337] case4(Client,Lock,MCRLFree1) -> false
[338] locker2_obtainables(nil,Client) -> true
[339] locker2_obtainables(cons(Lock,Locks),Client) ->
 case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock,pending)))
[340] case5(Client,Locks,Lock,true) ->
 andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
[341] case5(Client,Locks,Lock,false) -> locker2_obtainables(Locks,Client)
[342] locker2_check_available(Resource,nil) -> false
[343] locker2_check_available(Resource,cons(Lock,Locks)) ->
 case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock,resource)))
[344] case6(Locks,Lock,Resource,true) ->
 andt(equal(record_extract(Lock,lock,excl),nil),
  equal(record_extract(Lock,lock,pending),nil))
[345] case6(Locks,Lock,Resource,false) ->
 locker2_check_available(Resource,Locks)
[346] locker2_check_availables(nil,Locks) -> true
[347] locker2_check_availables(cons(Resource,Resources),Locks) ->
 andt(locker2_check_available(Resource,Locks),
  locker2_check_availables(Resources,Locks))
[348] locker2_adduniq(nil,List) -> List
[349] append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
[350] subtract(List,nil) -> List
[351] subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
[352] delete(E,nil) -> nil
[353] delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
[354] case8(Tail,Head,E,true) -> Tail
[355] case8(Tail,Head,E,false) -> cons(Head,delete(E,Tail))
[356] gen_tag(Pid) -> tuple(Pid,tuplenil(tag))
[357] gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
[358] member(E,nil) -> false
[359] member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
[360] case9(Tail,Head,E,true) -> true
[361] case9(Tail,Head,E,false) -> member(E,Tail)
[362] eqs(empty,empty) -> T
[363] eqs(empty,stack(E2,S2)) -> F
[364] eqs(stack(E1,S1),empty) -> F
[365] eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
[366] pushs(E1,S1) -> stack(E1,S1)
[367] pops(stack(E1,S1)) -> S1
[368] tops(stack(E1,S1)) -> E1
[369] istops(E1,empty) -> F
[370] istops(E1,stack(E2,S1)) -> eqt(E1,E2)
[371] eqc(nocalls,nocalls) -> T
[372] eqc(nocalls,calls(E2,S2,CS2)) -> F
[373] eqc(calls(E1,S1,CS1),nocalls) -> F
[374] eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) ->
 and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
[375] push(E1,E2,nocalls) -> calls(E1,stack(E2,empty),nocalls)
[376] push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
[377] push1(E1,E2,E3,S1,CS1,T) -> calls(E3,pushs(E2,S1),CS1)


Sub problem: 
guided: 

DP termination of:
<Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_and(eqt(H1,H2),eqt(T1,T2))>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_and(eqt(H1,H2),eqt(T1,T2))>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
<Marked_element(int(s(s(N1))),tuple(T1,T2)) , Marked_element(int(s(N1)),T2)>
<Marked_record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) , Marked_record_updates(
                                                                    record_update(
                                                                    Record,
                                                                    Name,
                                                                    Field,
                                                                    NewF),Name,
                                                                    Fields)>
<Marked_record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) , Marked_record_update(
                                                                    Record,
                                                                    Name,Field,
                                                                    NewF)>
<Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) , Marked_locker2_promote_pending(
                                                                 Lock,
                                                                 Pending)>
<Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) , Marked_locker2_map_promote_pending(
                                                                 Locks,
                                                                 Pending)>
<Marked_locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) , Marked_locker2_map_claim_lock(
                                                                    Locks,
                                                                    Resources,
                                                                    Client)>
<Marked_locker2_promote_pending(Lock,Client) , Marked_case0(Client,Lock,
                                                record_extract(Lock,lock,
                                                 pending))>
<Marked_locker2_promote_pending(Lock,Client) , Marked_record_extract(
                                                Lock,lock,pending)>
<Marked_case0(Client,Lock,cons(Client,Pendings)) , Marked_record_updates(
                                                    Lock,lock,
                                                    cons(tuple(excl,
                                                          tuplenil(Client)),
                                                     cons(tuple(pending,
                                                           tuplenil(Pendings)),
                                                      nil)))>
<Marked_locker2_remove_pending(Lock,Client) , Marked_record_updates(Lock,
                                               lock,
                                               cons(tuple(pending,
                                                     tuplenil(subtract(
                                                               record_extract(
                                                                Lock,
                                                                lock,
                                                                pending),
                                                               cons(Client,nil)))
                                                      ),nil))>
<Marked_locker2_remove_pending(Lock,Client) , Marked_subtract(record_extract(
                                                               Lock,lock,
                                                               pending),
                                               cons(Client,nil))>
<Marked_locker2_remove_pending(Lock,Client) , Marked_record_extract(Lock,
                                               lock,pending)>
<Marked_locker2_add_pending(Lock,Resources,Client) , Marked_case1(Client,
                                                      Resources,Lock,
                                                      member(record_extract(
                                                              Lock,lock,
                                                              resource),
                                                       Resources))>
<Marked_locker2_add_pending(Lock,Resources,Client) , Marked_member(record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource),
                                                      Resources)>
<Marked_locker2_add_pending(Lock,Resources,Client) , Marked_record_extract(
                                                      Lock,lock,resource)>
<Marked_case1(Client,Resources,Lock,true) , Marked_record_updates(Lock,
                                             lock,
                                             cons(tuple(pending,
                                                   tuplenil(append(record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                             cons(Client,nil)))),
                                              nil))>
<Marked_case1(Client,Resources,Lock,true) , Marked_append(record_extract(
                                                           Lock,lock,
                                                           pending),
                                             cons(Client,nil))>
<Marked_case1(Client,Resources,Lock,true) , Marked_record_extract(Lock,
                                             lock,pending)>
<Marked_locker2_release_lock(Lock,Client) , Marked_case2(Client,Lock,
                                             gen_modtageq(Client,
                                              record_extract(Lock,lock,excl)))>
<Marked_locker2_release_lock(Lock,Client) , Marked_gen_modtageq(Client,
                                             record_extract(Lock,lock,excl))>
<Marked_locker2_release_lock(Lock,Client) , Marked_record_extract(Lock,
                                             lock,excl)>
<Marked_case2(Client,Lock,true) , Marked_record_updates(Lock,lock,
                                   cons(tuple(excllock,excl),nil))>
<Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(Client,
                                                        Locks,Lock,
                                                        member(Client,
                                                         record_extract(
                                                          Lock,lock,pending)))>
<Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_member(
                                                        Client,
                                                        record_extract(
                                                         Lock,lock,pending))>
<Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_record_extract(
                                                        Lock,lock,pending)>
<Marked_case5(Client,Locks,Lock,true) , Marked_locker2_obtainables(Locks,
                                         Client)>
<Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(Locks,
                                          Client)>
<Marked_locker2_check_available(Resource,cons(Lock,Locks)) , Marked_case6(
                                                              Locks,Lock,
                                                              Resource,
                                                              equal(Resource,
                                                               record_extract(
                                                                Lock,
                                                                lock,
                                                                resource)))>
<Marked_locker2_check_available(Resource,cons(Lock,Locks)) , Marked_record_extract(
                                                              Lock,lock,
                                                              resource)>
<Marked_case6(Locks,Lock,Resource,true) , Marked_record_extract(Lock,lock,excl)>
<Marked_case6(Locks,Lock,Resource,true) , Marked_record_extract(Lock,
                                           lock,pending)>
<Marked_case6(Locks,Lock,Resource,false) , Marked_locker2_check_available(
                                            Resource,Locks)>
<Marked_locker2_check_availables(cons(Resource,Resources),Locks) , Marked_locker2_check_available(
                                                                    Resource,
                                                                    Locks)>
<Marked_locker2_check_availables(cons(Resource,Resources),Locks) , Marked_locker2_check_availables(
                                                                    Resources,
                                                                    Locks)>
<Marked_append(cons(Head,Tail),List) , Marked_append(Tail,List)>
<Marked_subtract(List,cons(Head,Tail)) , Marked_subtract(delete(Head,List),
                                          Tail)>
<Marked_subtract(List,cons(Head,Tail)) , Marked_delete(Head,List)>
<Marked_delete(E,cons(Head,Tail)) , Marked_case8(Tail,Head,E,equal(E,Head))>
<Marked_case8(Tail,Head,E,false) , Marked_delete(E,Tail)>
<Marked_member(E,cons(Head,Tail)) , Marked_case9(Tail,Head,E,equal(E,Head))>
<Marked_case9(Tail,Head,E,false) , Marked_member(E,Tail)>
<Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_and(eqt(E1,E2),eqs(S1,S2))>
<Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_eqt(E1,E2)>
<Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_eqs(S1,S2)>
<Marked_istops(E1,stack(E2,S1)) , Marked_eqt(E1,E2)>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_and(eqt(E1,E2),
                                                  and(eqs(S1,S2),eqc(CS1,CS2)))>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqt(E1,E2)>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_and(eqs(S1,S2),
                                                  eqc(CS1,CS2))>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqs(S1,S2)>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqc(CS1,CS2)>
<Marked_push(E1,E2,calls(E3,S1,CS1)) , Marked_push1(E1,E2,E3,S1,CS1,eqt(E1,E3))>
<Marked_push(E1,E2,calls(E3,S1,CS1)) , Marked_eqt(E1,E3)>
<Marked_push1(E1,E2,E3,S1,CS1,T) , Marked_pushs(E2,S1)>
 
END GUIDED
APPLY CRITERIA (Graph splitting)
Found 11 components:

{  <Marked_element(int(s(s(N1))),tuple(T1,T2)) , Marked_element(int(s(N1)),T2)> 
      --> <Marked_element(int(s(s(N1))),tuple(T1,T2)) , Marked_element(
                                                         int(s(N1)),T2)>
}

{  <Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) , Marked_locker2_map_promote_pending(
                                                                    Locks,
                                                                    Pending)> 
      --> <Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) , Marked_locker2_map_promote_pending(
                                                                    Locks,
                                                                    Pending)>
}

{  <Marked_locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) , Marked_locker2_map_claim_lock(
                                                                    Locks,
                                                                    Resources,
                                                                    Client)> 
      --> <Marked_locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) , Marked_locker2_map_claim_lock(
                                                                    Locks,
                                                                    Resources,
                                                                    Client)>
}

{  <Marked_record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) , Marked_record_updates(
                                                                    record_update(
                                                                    Record,
                                                                    Name,
                                                                    Field,
                                                                    NewF),Name,
                                                                    Fields)> 
      --> <Marked_record_updates(Record,Name,
            cons(tuple(Field,tuplenil(NewF)),Fields)) , Marked_record_updates(
                                                         record_update(
                                                          Record,Name,
                                                          Field,NewF),
                                                         Name,Fields)>
}

{  <Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(
                                             Locks,Client)> 
      --> <Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(
                                                                  Client,
                                                                  Locks,
                                                                  Lock,
                                                                  member(
                                                                   Client,
                                                                   record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending)))>
  <Marked_case5(Client,Locks,Lock,true) , Marked_locker2_obtainables(
                                           Locks,Client)> 
     --> <Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(
                                                                 Client,
                                                                 Locks,
                                                                 Lock,
                                                                 member(
                                                                  Client,
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending)))>
  <Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(
                                                          Client,Locks,
                                                          Lock,
                                                          member(Client,
                                                           record_extract(
                                                            Lock,lock,
                                                            pending)))> 
     --> <Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(
                                                   Locks,Client)>
  <Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(
                                                          Client,Locks,
                                                          Lock,
                                                          member(Client,
                                                           record_extract(
                                                            Lock,lock,
                                                            pending)))> 
     --> <Marked_case5(Client,Locks,Lock,true) , Marked_locker2_obtainables(
                                                  Locks,Client)>
}

{  <Marked_locker2_check_availables(cons(Resource,Resources),Locks) , Marked_locker2_check_availables(
                                                                    Resources,
                                                                    Locks)> 
      --> <Marked_locker2_check_availables(cons(Resource,Resources),Locks) , Marked_locker2_check_availables(
                                                                    Resources,
                                                                    Locks)>
}

{  <Marked_append(cons(Head,Tail),List) , Marked_append(Tail,List)> 
      --> <Marked_append(cons(Head,Tail),List) , Marked_append(Tail,List)>
}

{  <Marked_subtract(List,cons(Head,Tail)) , Marked_subtract(delete(Head,List),
                                             Tail)> 
      --> <Marked_subtract(List,cons(Head,Tail)) , Marked_subtract(delete(
                                                                    Head,
                                                                    List),
                                                    Tail)>
}

{  <Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqc(CS1,CS2)> 
      --> <Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqc(CS1,CS2)>
}

{  <Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_eqs(S1,S2)> 
      --> <Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_eqs(S1,S2)>
}

{  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
      --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
  <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)> 
     --> <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_element(int(s(s(N1))),tuple(T1,T2)) >= Marked_element(int(s(N1)),T2) ;
 }
 + Disjunctions:{ 
{
  Marked_element(int(s(s(N1))),tuple(T1,T2)) > Marked_element(int(s(N1)),T2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_element(int(s(s(N1))),tuple(T1,T2)) >= Marked_element(
                                                           int(s(N1)),
                                                           T2)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) >= Marked_locker2_map_promote_pending(
                                                                   Locks,
                                                                   Pending) ;
 }
 + Disjunctions:{ 
{
  Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) > Marked_locker2_map_promote_pending(
                                                                  Locks,
                                                                  Pending) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
Marked_locker2_map_promote_pending(Locks,Pending)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
Marked_locker2_map_claim_lock(Locks,Resources,Client) ;
 }
 + Disjunctions:{ 
{
  Marked_locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) > 
Marked_locker2_map_claim_lock(Locks,Resources,Client) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
Marked_locker2_map_claim_lock(Locks,Resources,Client)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
Marked_record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
 }
 + Disjunctions:{ 
{
  Marked_record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) > 
Marked_record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= Marked_record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_case5(Client,Locks,Lock,false) >= Marked_locker2_obtainables(
                                            Locks,Client) ;
  Marked_case5(Client,Locks,Lock,true) >= Marked_locker2_obtainables(
                                           Locks,Client) ;
  Marked_locker2_obtainables(cons(Lock,Locks),Client) >= Marked_case5(
                                                          Client,Locks,
                                                          Lock,
                                                          member(Client,
                                                           record_extract(
                                                            Lock,lock,
                                                            pending))) ;
 }
 + Disjunctions:{ 
{
  Marked_case5(Client,Locks,Lock,false) > Marked_locker2_obtainables(
                                           Locks,Client) ;
 }
{
  Marked_case5(Client,Locks,Lock,true) > Marked_locker2_obtainables(Locks,
                                          Client) ;
 }
{
  Marked_locker2_obtainables(cons(Lock,Locks),Client) > Marked_case5(
                                                         Client,Locks,
                                                         Lock,
                                                         member(Client,
                                                          record_extract(
                                                           Lock,lock,
                                                           pending))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_case5(Client,Locks,Lock,false) >= Marked_locker2_obtainables(
                                                      Locks,Client)
constraint: Marked_case5(Client,Locks,Lock,true) >= Marked_locker2_obtainables(
                                                     Locks,Client)
constraint: Marked_locker2_obtainables(cons(Lock,Locks),Client) >= Marked_case5(
                                                                    Client,
                                                                    Locks,
                                                                    Lock,
                                                                    member(
                                                                    Client,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending)))
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_locker2_check_availables(cons(Resource,Resources),Locks) >= 
Marked_locker2_check_availables(Resources,Locks) ;
 }
 + Disjunctions:{ 
{
  Marked_locker2_check_availables(cons(Resource,Resources),Locks) > Marked_locker2_check_availables(
                                                                    Resources,
                                                                    Locks) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_locker2_check_availables(cons(Resource,Resources),Locks) >= 
Marked_locker2_check_availables(Resources,Locks)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_append(cons(Head,Tail),List) >= Marked_append(Tail,List) ;
 }
 + Disjunctions:{ 
{
  Marked_append(cons(Head,Tail),List) > Marked_append(Tail,List) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_append(cons(Head,Tail),List) >= Marked_append(Tail,List)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_subtract(List,cons(Head,Tail)) >= Marked_subtract(delete(Head,List),
                                            Tail) ;
 }
 + Disjunctions:{ 
{
  Marked_subtract(List,cons(Head,Tail)) > Marked_subtract(delete(Head,List),
                                           Tail) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_subtract(List,cons(Head,Tail)) >= Marked_subtract(
                                                      delete(Head,List),
                                                      Tail)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= Marked_eqc(CS1,CS2) ;
 }
 + Disjunctions:{ 
{
  Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) > Marked_eqc(CS1,CS2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= Marked_eqc(
                                                              CS1,CS2)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_eqs(stack(E1,S1),stack(E2,S2)) >= Marked_eqs(S1,S2) ;
 }
 + Disjunctions:{ 
{
  Marked_eqs(stack(E1,S1),stack(E2,S2)) > Marked_eqs(S1,S2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_eqs(stack(E1,S1),stack(E2,S2)) >= Marked_eqs(S1,S2)
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_eqt(pid(N1),pid(N2)) >= Marked_eqt(N1,N2) ;
  Marked_eqt(cons(H1,T1),cons(H2,T2)) >= Marked_eqt(T1,T2) ;
  Marked_eqt(cons(H1,T1),cons(H2,T2)) >= Marked_eqt(H1,H2) ;
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(T1,T2) ;
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(H1,H2) ;
  Marked_eqt(tuplenil(H1),tuplenil(H2)) >= Marked_eqt(H1,H2) ;
 }
 + Disjunctions:{ 
{
  Marked_eqt(pid(N1),pid(N2)) > Marked_eqt(N1,N2) ;
 }
{
  Marked_eqt(cons(H1,T1),cons(H2,T2)) > Marked_eqt(T1,T2) ;
 }
{
  Marked_eqt(cons(H1,T1),cons(H2,T2)) > Marked_eqt(H1,H2) ;
 }
{
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) > Marked_eqt(T1,T2) ;
 }
{
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) > Marked_eqt(H1,H2) ;
 }
{
  Marked_eqt(tuplenil(H1),tuplenil(H2)) > Marked_eqt(H1,H2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_eqt(pid(N1),pid(N2)) >= Marked_eqt(N1,N2)
constraint: Marked_eqt(cons(H1,T1),cons(H2,T2)) >= Marked_eqt(T1,T2)
constraint: Marked_eqt(cons(H1,T1),cons(H2,T2)) >= Marked_eqt(H1,H2)
constraint: Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(T1,T2)
constraint: Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(H1,H2)
constraint: Marked_eqt(tuplenil(H1),tuplenil(H2)) >= Marked_eqt(H1,H2)
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(
                                             Locks,Client)> 
      --> <Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(
                                                                  Client,
                                                                  Locks,
                                                                  Lock,
                                                                  member(
                                                                   Client,
                                                                   record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending)))>
  <Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(
                                                          Client,Locks,
                                                          Lock,
                                                          member(Client,
                                                           record_extract(
                                                            Lock,lock,
                                                            pending)))> 
     --> <Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(
                                                   Locks,Client)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_case5(Client,Locks,Lock,false) >= Marked_locker2_obtainables(
                                            Locks,Client) ;
  Marked_locker2_obtainables(cons(Lock,Locks),Client) >= Marked_case5(
                                                          Client,Locks,
                                                          Lock,
                                                          member(Client,
                                                           record_extract(
                                                            Lock,lock,
                                                            pending))) ;
 }
 + Disjunctions:{ 
{
  Marked_case5(Client,Locks,Lock,false) > Marked_locker2_obtainables(
                                           Locks,Client) ;
 }
{
  Marked_locker2_obtainables(cons(Lock,Locks),Client) > Marked_case5(
                                                         Client,Locks,
                                                         Lock,
                                                         member(Client,
                                                          record_extract(
                                                           Lock,lock,
                                                           pending))) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_case5(Client,Locks,Lock,false) >= Marked_locker2_obtainables(
                                                      Locks,Client)
constraint: Marked_locker2_obtainables(cons(Lock,Locks),Client) >= Marked_case5(
                                                                    Client,
                                                                    Locks,
                                                                    Lock,
                                                                    member(
                                                                    Client,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending)))
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 0 components:
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
      --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_eqt(cons(H1,T1),cons(H2,T2)) >= Marked_eqt(T1,T2) ;
  Marked_eqt(cons(H1,T1),cons(H2,T2)) >= Marked_eqt(H1,H2) ;
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(T1,T2) ;
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(H1,H2) ;
  Marked_eqt(tuplenil(H1),tuplenil(H2)) >= Marked_eqt(H1,H2) ;
 }
 + Disjunctions:{ 
{
  Marked_eqt(cons(H1,T1),cons(H2,T2)) > Marked_eqt(T1,T2) ;
 }
{
  Marked_eqt(cons(H1,T1),cons(H2,T2)) > Marked_eqt(H1,H2) ;
 }
{
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) > Marked_eqt(T1,T2) ;
 }
{
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) > Marked_eqt(H1,H2) ;
 }
{
  Marked_eqt(tuplenil(H1),tuplenil(H2)) > Marked_eqt(H1,H2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_eqt(cons(H1,T1),cons(H2,T2)) >= Marked_eqt(T1,T2)
constraint: Marked_eqt(cons(H1,T1),cons(H2,T2)) >= Marked_eqt(H1,H2)
constraint: Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(T1,T2)
constraint: Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(H1,H2)
constraint: Marked_eqt(tuplenil(H1),tuplenil(H2)) >= Marked_eqt(H1,H2)
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
      --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
  <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)> 
     --> <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(T1,T2) ;
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(H1,H2) ;
  Marked_eqt(tuplenil(H1),tuplenil(H2)) >= Marked_eqt(H1,H2) ;
 }
 + Disjunctions:{ 
{
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) > Marked_eqt(T1,T2) ;
 }
{
  Marked_eqt(tuple(H1,T1),tuple(H2,T2)) > Marked_eqt(H1,H2) ;
 }
{
  Marked_eqt(tuplenil(H1),tuplenil(H2)) > Marked_eqt(H1,H2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(T1,T2)
constraint: Marked_eqt(tuple(H1,T1),tuple(H2,T2)) >= Marked_eqt(H1,H2)
constraint: Marked_eqt(tuplenil(H1),tuplenil(H2)) >= Marked_eqt(H1,H2)
APPLY CRITERIA (Graph splitting)
Found 1 components:

{  <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)> 
      --> <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
}
APPLY CRITERIA (Choosing graph)
Trying to solve the following constraints:
{
  or(T,T) >= T ;
  or(T,F) >= T ;
  or(F,T) >= T ;
  or(F,F) >= F ;
  and(T,B) >= B ;
  and(F,B) >= F ;
  and(B,T) >= B ;
  and(B,F) >= F ;
  imp(T,B) >= B ;
  imp(F,B) >= T ;
  not(T) >= F ;
  not(F) >= T ;
  if(T,B1,B2) >= B1 ;
  if(F,B1,B2) >= B2 ;
  eq(T,T) >= T ;
  eq(T,F) >= F ;
  eq(F,T) >= F ;
  eq(F,F) >= T ;
  eqt(nil,undefined) >= F ;
  eqt(nil,pid(N2)) >= F ;
  eqt(nil,int(N2)) >= F ;
  eqt(nil,cons(H2,T2)) >= F ;
  eqt(nil,tuple(H2,T2)) >= F ;
  eqt(nil,tuplenil(H2)) >= F ;
  eqt(undefined,nil) >= F ;
  eqt(undefined,tuplenil(H2)) >= F ;
  eqt(undefined,a) >= F ;
  eqt(pid(N1),nil) >= F ;
  eqt(pid(N1),undefined) >= F ;
  eqt(pid(N1),pid(N2)) >= eqt(N1,N2) ;
  eqt(pid(N1),int(N2)) >= F ;
  eqt(pid(N1),cons(H2,T2)) >= F ;
  eqt(pid(N1),tuple(H2,T2)) >= F ;
  eqt(pid(N1),tuplenil(H2)) >= F ;
  eqt(pid(N1),a) >= F ;
  eqt(pid(N1),excl) >= F ;
  eqt(pid(N1),false) >= F ;
  eqt(pid(N1),lock) >= F ;
  eqt(pid(N1),locker) >= F ;
  eqt(pid(N1),mcrlrecord) >= F ;
  eqt(pid(N1),ok) >= F ;
  eqt(pid(N1),pending) >= F ;
  eqt(pid(N1),release) >= F ;
  eqt(pid(N1),request) >= F ;
  eqt(pid(N1),resource) >= F ;
  eqt(pid(N1),tag) >= F ;
  eqt(pid(N1),true) >= F ;
  eqt(int(N1),nil) >= F ;
  eqt(int(N1),undefined) >= F ;
  eqt(int(N1),a) >= F ;
  eqt(int(N1),excl) >= F ;
  eqt(int(N1),false) >= F ;
  eqt(int(N1),lock) >= F ;
  eqt(int(N1),locker) >= F ;
  eqt(int(N1),mcrlrecord) >= F ;
  eqt(int(N1),ok) >= F ;
  eqt(int(N1),pending) >= F ;
  eqt(int(N1),release) >= F ;
  eqt(int(N1),request) >= F ;
  eqt(int(N1),resource) >= F ;
  eqt(int(N1),tag) >= F ;
  eqt(int(N1),true) >= F ;
  eqt(cons(H1,T1),undefined) >= F ;
  eqt(cons(H1,T1),pid(N2)) >= F ;
  eqt(cons(H1,T1),int(N2)) >= F ;
  eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(cons(H1,T1),tuple(H2,T2)) >= F ;
  eqt(cons(H1,T1),tuplenil(H2)) >= F ;
  eqt(cons(H1,T1),resource) >= F ;
  eqt(cons(H1,T1),tag) >= F ;
  eqt(cons(H1,T1),true) >= F ;
  eqt(tuple(H1,T1),nil) >= F ;
  eqt(tuple(H1,T1),undefined) >= F ;
  eqt(tuple(H1,T1),pid(N2)) >= F ;
  eqt(tuple(H1,T1),int(N2)) >= F ;
  eqt(tuple(H1,T1),cons(H2,T2)) >= F ;
  eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2)) ;
  eqt(tuple(H1,T1),tuplenil(H2)) >= F ;
  eqt(tuple(H1,T1),a) >= F ;
  eqt(tuple(H1,T1),excl) >= F ;
  eqt(tuple(H1,T1),false) >= F ;
  eqt(tuple(H1,T1),lock) >= F ;
  eqt(tuple(H1,T1),locker) >= F ;
  eqt(tuple(H1,T1),mcrlrecord) >= F ;
  eqt(tuple(H1,T1),ok) >= F ;
  eqt(tuple(H1,T1),pending) >= F ;
  eqt(tuple(H1,T1),release) >= F ;
  eqt(tuple(H1,T1),request) >= F ;
  eqt(tuple(H1,T1),resource) >= F ;
  eqt(tuple(H1,T1),tag) >= F ;
  eqt(tuple(H1,T1),true) >= F ;
  eqt(tuplenil(H1),nil) >= F ;
  eqt(tuplenil(H1),undefined) >= F ;
  eqt(tuplenil(H1),pid(N2)) >= F ;
  eqt(tuplenil(H1),int(N2)) >= F ;
  eqt(tuplenil(H1),cons(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuple(H2,T2)) >= F ;
  eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2) ;
  eqt(tuplenil(H1),a) >= F ;
  eqt(tuplenil(H1),excl) >= F ;
  eqt(tuplenil(H1),false) >= F ;
  eqt(tuplenil(H1),lock) >= F ;
  eqt(tuplenil(H1),locker) >= F ;
  eqt(tuplenil(H1),mcrlrecord) >= F ;
  eqt(tuplenil(H1),ok) >= F ;
  eqt(tuplenil(H1),pending) >= F ;
  eqt(tuplenil(H1),release) >= F ;
  eqt(tuplenil(H1),request) >= F ;
  eqt(tuplenil(H1),resource) >= F ;
  eqt(tuplenil(H1),tag) >= F ;
  eqt(tuplenil(H1),true) >= F ;
  eqt(a,nil) >= F ;
  eqt(a,undefined) >= F ;
  eqt(a,pid(N2)) >= F ;
  eqt(a,int(N2)) >= F ;
  eqt(a,cons(H2,T2)) >= F ;
  eqt(a,tuple(H2,T2)) >= F ;
  eqt(a,tuplenil(H2)) >= F ;
  eqt(a,a) >= T ;
  eqt(a,excl) >= F ;
  eqt(a,false) >= F ;
  eqt(a,lock) >= F ;
  eqt(a,locker) >= F ;
  eqt(a,mcrlrecord) >= F ;
  eqt(a,ok) >= F ;
  eqt(a,pending) >= F ;
  eqt(a,release) >= F ;
  eqt(a,request) >= F ;
  eqt(a,resource) >= F ;
  eqt(a,tag) >= F ;
  eqt(a,true) >= F ;
  eqt(excl,eqt(false,int(N2))) >= F ;
  eqt(excl,nil) >= F ;
  eqt(excl,undefined) >= F ;
  eqt(excl,pid(N2)) >= F ;
  eqt(excl,a) >= F ;
  eqt(excl,excl) >= T ;
  eqt(excl,false) >= F ;
  eqt(excl,lock) >= F ;
  eqt(excl,locker) >= F ;
  eqt(excl,mcrlrecord) >= F ;
  eqt(excl,ok) >= F ;
  eqt(excl,pending) >= F ;
  eqt(excl,release) >= F ;
  eqt(excl,request) >= F ;
  eqt(excl,resource) >= F ;
  eqt(excl,tag) >= F ;
  eqt(excl,true) >= F ;
  eqt(false,cons(H2,T2)) >= F ;
  eqt(false,tuple(H2,T2)) >= F ;
  eqt(false,tuplenil(H2)) >= F ;
  eqt(lock,nil) >= F ;
  eqt(lock,undefined) >= F ;
  eqt(lock,pid(N2)) >= F ;
  eqt(lock,int(N2)) >= F ;
  eqt(lock,cons(H2,T2)) >= F ;
  eqt(lock,tuple(H2,T2)) >= F ;
  eqt(lock,tuplenil(H2)) >= F ;
  eqt(lock,a) >= F ;
  eqt(lock,excl) >= F ;
  eqt(lock,false) >= F ;
  eqt(lock,lock) >= T ;
  eqt(lock,locker) >= F ;
  eqt(lock,mcrlrecord) >= F ;
  eqt(lock,ok) >= F ;
  eqt(lock,pending) >= F ;
  eqt(lock,release) >= F ;
  eqt(lock,request) >= F ;
  eqt(lock,resource) >= F ;
  eqt(lock,tag) >= F ;
  eqt(lock,true) >= F ;
  eqt(locker,nil) >= F ;
  eqt(locker,undefined) >= F ;
  eqt(locker,pid(N2)) >= F ;
  eqt(locker,int(N2)) >= F ;
  eqt(locker,cons(H2,T2)) >= F ;
  eqt(locker,tuple(H2,T2)) >= F ;
  eqt(locker,tuplenil(H2)) >= F ;
  eqt(locker,a) >= F ;
  eqt(locker,excl) >= F ;
  eqt(locker,false) >= F ;
  eqt(locker,lock) >= F ;
  eqt(locker,locker) >= T ;
  eqt(locker,mcrlrecord) >= F ;
  eqt(locker,ok) >= F ;
  eqt(locker,pending) >= F ;
  eqt(locker,release) >= F ;
  eqt(locker,request) >= F ;
  eqt(locker,resource) >= F ;
  eqt(locker,tag) >= F ;
  eqt(locker,true) >= F ;
  eqt(mcrlrecord,nil) >= F ;
  eqt(mcrlrecord,a) >= F ;
  eqt(mcrlrecord,excl) >= F ;
  eqt(mcrlrecord,false) >= F ;
  eqt(mcrlrecord,lock) >= F ;
  eqt(mcrlrecord,locker) >= F ;
  eqt(mcrlrecord,mcrlrecord) >= T ;
  eqt(mcrlrecord,ok) >= F ;
  eqt(mcrlrecord,pending) >= F ;
  eqt(mcrlrecord,release) >= F ;
  eqt(mcrlrecord,request) >= F ;
  eqt(mcrlrecord,resource) >= F ;
  eqt(ok,undefined) >= F ;
  eqt(ok,pid(N2)) >= F ;
  eqt(ok,int(N2)) >= F ;
  eqt(ok,cons(H2,T2)) >= F ;
  eqt(ok,tuple(H2,T2)) >= F ;
  eqt(ok,tuplenil(H2)) >= F ;
  eqt(ok,resource) >= F ;
  eqt(ok,tag) >= F ;
  eqt(ok,true) >= F ;
  eqt(pending,nil) >= F ;
  eqt(pending,undefined) >= F ;
  eqt(pending,pid(N2)) >= F ;
  eqt(pending,int(N2)) >= F ;
  eqt(pending,cons(H2,T2)) >= F ;
  eqt(pending,tuple(H2,T2)) >= F ;
  eqt(pending,tuplenil(H2)) >= F ;
  eqt(pending,a) >= F ;
  eqt(pending,excl) >= F ;
  eqt(pending,false) >= F ;
  eqt(pending,lock) >= F ;
  eqt(pending,locker) >= F ;
  eqt(pending,mcrlrecord) >= F ;
  eqt(pending,ok) >= F ;
  eqt(pending,pending) >= T ;
  eqt(pending,release) >= F ;
  eqt(pending,request) >= F ;
  eqt(pending,resource) >= F ;
  eqt(pending,tag) >= F ;
  eqt(pending,true) >= F ;
  eqt(release,nil) >= F ;
  eqt(release,a) >= F ;
  eqt(release,excl) >= F ;
  eqt(release,false) >= F ;
  eqt(release,lock) >= F ;
  eqt(release,locker) >= F ;
  eqt(release,mcrlrecord) >= F ;
  eqt(release,ok) >= F ;
  eqt(request,undefined) >= F ;
  eqt(request,pid(N2)) >= F ;
  eqt(request,int(N2)) >= F ;
  eqt(request,cons(H2,T2)) >= F ;
  eqt(request,tuple(H2,T2)) >= F ;
  eqt(request,tuplenil(H2)) >= F ;
  eqt(request,mcrlrecord) >= F ;
  eqt(request,ok) >= F ;
  eqt(request,pending) >= F ;
  eqt(request,release) >= F ;
  eqt(request,request) >= T ;
  eqt(request,resource) >= F ;
  eqt(request,tag) >= F ;
  eqt(request,true) >= F ;
  eqt(resource,nil) >= F ;
  eqt(resource,undefined) >= F ;
  eqt(resource,pid(N2)) >= F ;
  eqt(resource,int(N2)) >= F ;
  eqt(resource,cons(H2,T2)) >= F ;
  eqt(resource,tuple(H2,T2)) >= F ;
  eqt(resource,tuplenil(H2)) >= F ;
  eqt(resource,a) >= F ;
  eqt(resource,excl) >= F ;
  eqt(resource,false) >= F ;
  eqt(resource,lock) >= F ;
  eqt(resource,locker) >= F ;
  eqt(resource,mcrlrecord) >= F ;
  eqt(resource,ok) >= F ;
  eqt(resource,pending) >= F ;
  eqt(resource,release) >= F ;
  eqt(resource,request) >= F ;
  eqt(resource,resource) >= T ;
  eqt(resource,tag) >= F ;
  eqt(resource,true) >= F ;
  eqt(tag,nil) >= F ;
  eqt(tag,undefined) >= F ;
  eqt(tag,pid(N2)) >= F ;
  eqt(tag,int(N2)) >= F ;
  eqt(tag,cons(H2,T2)) >= F ;
  eqt(tag,tuple(H2,T2)) >= F ;
  eqt(tag,tuplenil(H2)) >= F ;
  eqt(tag,a) >= F ;
  eqt(tag,excl) >= F ;
  eqt(tag,false) >= F ;
  eqt(tag,lock) >= F ;
  eqt(tag,locker) >= F ;
  eqt(tag,mcrlrecord) >= F ;
  eqt(tag,ok) >= F ;
  eqt(tag,pending) >= F ;
  eqt(tag,release) >= F ;
  eqt(tag,request) >= F ;
  eqt(tag,resource) >= F ;
  eqt(tag,tag) >= T ;
  eqt(tag,true) >= F ;
  eqt(true,nil) >= F ;
  eqt(true,undefined) >= F ;
  eqt(true,pid(N2)) >= F ;
  eqt(true,int(N2)) >= F ;
  eqt(true,cons(H2,T2)) >= F ;
  eqt(true,tuple(H2,T2)) >= F ;
  eqt(true,tuplenil(H2)) >= F ;
  eqt(true,a) >= F ;
  eqt(true,excl) >= F ;
  eqt(true,false) >= F ;
  eqt(true,lock) >= F ;
  eqt(true,locker) >= F ;
  eqt(true,mcrlrecord) >= F ;
  eqt(true,ok) >= F ;
  eqt(true,pending) >= F ;
  eqt(true,release) >= F ;
  eqt(true,request) >= F ;
  eqt(true,resource) >= F ;
  eqt(true,tag) >= F ;
  eqt(true,true) >= T ;
  element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2) ;
  element(int(s(0)),tuple(T1,T2)) >= T1 ;
  element(int(s(0)),tuplenil(T1)) >= T1 ;
  record_new(lock) >= tuple(mcrlrecord,
                       tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) ;
  record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,resource) >= tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))) ;
  record_update(tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
   lock,pending,NewF) >= tuple(mcrlrecord,
                          tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF))))) ;
  record_updates(Record,Name,nil) >= Record ;
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) >= 
record_updates(record_update(Record,Name,Field,NewF),Name,Fields) ;
  locker2_map_promote_pending(nil,Pending) >= nil ;
  locker2_map_promote_pending(cons(Lock,Locks),Pending) >= cons(locker2_promote_pending(
                                                                 Lock,
                                                                 Pending),
                                                            locker2_map_promote_pending(
                                                             Locks,Pending)) ;
  locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                           record_extract(Lock,lock,pending)) ;
  locker2_map_claim_lock(nil,Resources,Client) >= nil ;
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= cons(locker2_claim_lock(
                                                                    Lock,
                                                                    Resources,
                                                                    Client),
                                                                locker2_map_claim_lock(
                                                                 Locks,
                                                                 Resources,
                                                                 Client)) ;
  locker2_map_add_pending(nil,Resources,Client) >= nil ;
  case0(Client,Lock,cons(Client,Pendings)) >= record_updates(Lock,lock,
                                               cons(tuple(excl,
                                                     tuplenil(Client)),
                                                cons(tuple(pending,
                                                      tuplenil(Pendings)),
                                                 nil))) ;
  case0(Client,Lock,MCRLFree0) >= Lock ;
  subtract(List,nil) >= List ;
  subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail) ;
  locker2_remove_pending(Lock,Client) >= record_updates(Lock,lock,
                                          cons(tuple(pending,
                                                tuplenil(subtract(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                          cons(Client,nil)))),
                                           nil)) ;
  case1(Client,Resources,Lock,false) >= Lock ;
  case1(Client,Resources,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(pending,
                                              tuplenil(append(record_extract(
                                                               Lock,lock,
                                                               pending),
                                                        cons(Client,nil)))),
                                         nil)) ;
  member(E,nil) >= false ;
  member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head)) ;
  locker2_add_pending(Lock,Resources,Client) >= case1(Client,Resources,
                                                 Lock,
                                                 member(record_extract(
                                                         Lock,lock,resource),
                                                  Resources)) ;
  append(cons(Head,Tail),List) >= cons(Head,append(Tail,List)) ;
  case2(Client,Lock,true) >= record_updates(Lock,lock,
                              cons(tuple(excllock,excl),nil)) ;
  gen_modtageq(Client1,Client2) >= equal(Client1,Client2) ;
  locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                        gen_modtageq(Client,
                                         record_extract(Lock,lock,excl))) ;
  case4(Client,Lock,MCRLFree1) >= false ;
  locker2_obtainables(nil,Client) >= true ;
  locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,Locks,
                                                   Lock,
                                                   member(Client,
                                                    record_extract(Lock,
                                                     lock,pending))) ;
  case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client) ;
  case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(Lock,Client),
                                    locker2_obtainables(Locks,Client)) ;
  locker2_check_available(Resource,nil) >= false ;
  locker2_check_available(Resource,cons(Lock,Locks)) >= case6(Locks,Lock,
                                                         Resource,
                                                         equal(Resource,
                                                          record_extract(
                                                           Lock,lock,
                                                           resource))) ;
  case6(Locks,Lock,Resource,false) >= locker2_check_available(Resource,Locks) ;
  case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(Lock,lock,excl),
                                           nil),
                                      equal(record_extract(Lock,lock,pending),
                                       nil)) ;
  locker2_check_availables(nil,Locks) >= true ;
  locker2_check_availables(cons(Resource,Resources),Locks) >= andt(locker2_check_available(
                                                                    Resource,
                                                                    Locks),
                                                               locker2_check_availables(
                                                                Resources,
                                                                Locks)) ;
  locker2_adduniq(nil,List) >= List ;
  delete(E,nil) >= nil ;
  delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head)) ;
  case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail)) ;
  case8(Tail,Head,E,true) >= Tail ;
  gen_tag(Pid) >= tuple(Pid,tuplenil(tag)) ;
  case9(Tail,Head,E,false) >= member(E,Tail) ;
  case9(Tail,Head,E,true) >= true ;
  eqs(empty,empty) >= T ;
  eqs(empty,stack(E2,S2)) >= F ;
  eqs(stack(E1,S1),empty) >= F ;
  eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2)) ;
  pushs(E1,S1) >= stack(E1,S1) ;
  pops(stack(E1,S1)) >= S1 ;
  tops(stack(E1,S1)) >= E1 ;
  istops(E1,empty) >= F ;
  istops(E1,stack(E2,S1)) >= eqt(E1,E2) ;
  eqc(nocalls,nocalls) >= T ;
  eqc(nocalls,calls(E2,S2,CS2)) >= F ;
  eqc(calls(E1,S1,CS1),nocalls) >= F ;
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                             and(eqs(S1,S2),eqc(CS1,CS2))) ;
  push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls) ;
  push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3)) ;
  push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1) ;
  Marked_eqt(tuplenil(H1),tuplenil(H2)) >= Marked_eqt(H1,H2) ;
 }
 + Disjunctions:{ 
{
  Marked_eqt(tuplenil(H1),tuplenil(H2)) > Marked_eqt(H1,H2) ;
 }
 } 
=== TIMER virtual : 10.000000 ===
Entering poly_solver
Starting Sat solver initialization
Calling Sat solver...
=== STOPING TIMER virtual ===
=== TIMER real : 10.000000 ===
=== STOPING TIMER real ===
Sat solver returned
Sat solver result read
=== STOPING TIMER real ===
=== STOPING TIMER virtual ===
constraint: or(T,T) >= T
constraint: or(T,F) >= T
constraint: or(F,T) >= T
constraint: or(F,F) >= F
constraint: and(T,B) >= B
constraint: and(F,B) >= F
constraint: and(B,T) >= B
constraint: and(B,F) >= F
constraint: imp(T,B) >= B
constraint: imp(F,B) >= T
constraint: not(T) >= F
constraint: not(F) >= T
constraint: if(T,B1,B2) >= B1
constraint: if(F,B1,B2) >= B2
constraint: eq(T,T) >= T
constraint: eq(T,F) >= F
constraint: eq(F,T) >= F
constraint: eq(F,F) >= T
constraint: eqt(nil,undefined) >= F
constraint: eqt(nil,pid(N2)) >= F
constraint: eqt(nil,int(N2)) >= F
constraint: eqt(nil,cons(H2,T2)) >= F
constraint: eqt(nil,tuple(H2,T2)) >= F
constraint: eqt(nil,tuplenil(H2)) >= F
constraint: eqt(undefined,nil) >= F
constraint: eqt(undefined,tuplenil(H2)) >= F
constraint: eqt(undefined,a) >= F
constraint: eqt(pid(N1),nil) >= F
constraint: eqt(pid(N1),undefined) >= F
constraint: eqt(pid(N1),pid(N2)) >= eqt(N1,N2)
constraint: eqt(pid(N1),int(N2)) >= F
constraint: eqt(pid(N1),cons(H2,T2)) >= F
constraint: eqt(pid(N1),tuple(H2,T2)) >= F
constraint: eqt(pid(N1),tuplenil(H2)) >= F
constraint: eqt(pid(N1),a) >= F
constraint: eqt(pid(N1),excl) >= F
constraint: eqt(pid(N1),false) >= F
constraint: eqt(pid(N1),lock) >= F
constraint: eqt(pid(N1),locker) >= F
constraint: eqt(pid(N1),mcrlrecord) >= F
constraint: eqt(pid(N1),ok) >= F
constraint: eqt(pid(N1),pending) >= F
constraint: eqt(pid(N1),release) >= F
constraint: eqt(pid(N1),request) >= F
constraint: eqt(pid(N1),resource) >= F
constraint: eqt(pid(N1),tag) >= F
constraint: eqt(pid(N1),true) >= F
constraint: eqt(int(N1),nil) >= F
constraint: eqt(int(N1),undefined) >= F
constraint: eqt(int(N1),a) >= F
constraint: eqt(int(N1),excl) >= F
constraint: eqt(int(N1),false) >= F
constraint: eqt(int(N1),lock) >= F
constraint: eqt(int(N1),locker) >= F
constraint: eqt(int(N1),mcrlrecord) >= F
constraint: eqt(int(N1),ok) >= F
constraint: eqt(int(N1),pending) >= F
constraint: eqt(int(N1),release) >= F
constraint: eqt(int(N1),request) >= F
constraint: eqt(int(N1),resource) >= F
constraint: eqt(int(N1),tag) >= F
constraint: eqt(int(N1),true) >= F
constraint: eqt(cons(H1,T1),undefined) >= F
constraint: eqt(cons(H1,T1),pid(N2)) >= F
constraint: eqt(cons(H1,T1),int(N2)) >= F
constraint: eqt(cons(H1,T1),cons(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(cons(H1,T1),tuple(H2,T2)) >= F
constraint: eqt(cons(H1,T1),tuplenil(H2)) >= F
constraint: eqt(cons(H1,T1),resource) >= F
constraint: eqt(cons(H1,T1),tag) >= F
constraint: eqt(cons(H1,T1),true) >= F
constraint: eqt(tuple(H1,T1),nil) >= F
constraint: eqt(tuple(H1,T1),undefined) >= F
constraint: eqt(tuple(H1,T1),pid(N2)) >= F
constraint: eqt(tuple(H1,T1),int(N2)) >= F
constraint: eqt(tuple(H1,T1),cons(H2,T2)) >= F
constraint: eqt(tuple(H1,T1),tuple(H2,T2)) >= and(eqt(H1,H2),eqt(T1,T2))
constraint: eqt(tuple(H1,T1),tuplenil(H2)) >= F
constraint: eqt(tuple(H1,T1),a) >= F
constraint: eqt(tuple(H1,T1),excl) >= F
constraint: eqt(tuple(H1,T1),false) >= F
constraint: eqt(tuple(H1,T1),lock) >= F
constraint: eqt(tuple(H1,T1),locker) >= F
constraint: eqt(tuple(H1,T1),mcrlrecord) >= F
constraint: eqt(tuple(H1,T1),ok) >= F
constraint: eqt(tuple(H1,T1),pending) >= F
constraint: eqt(tuple(H1,T1),release) >= F
constraint: eqt(tuple(H1,T1),request) >= F
constraint: eqt(tuple(H1,T1),resource) >= F
constraint: eqt(tuple(H1,T1),tag) >= F
constraint: eqt(tuple(H1,T1),true) >= F
constraint: eqt(tuplenil(H1),nil) >= F
constraint: eqt(tuplenil(H1),undefined) >= F
constraint: eqt(tuplenil(H1),pid(N2)) >= F
constraint: eqt(tuplenil(H1),int(N2)) >= F
constraint: eqt(tuplenil(H1),cons(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuple(H2,T2)) >= F
constraint: eqt(tuplenil(H1),tuplenil(H2)) >= eqt(H1,H2)
constraint: eqt(tuplenil(H1),a) >= F
constraint: eqt(tuplenil(H1),excl) >= F
constraint: eqt(tuplenil(H1),false) >= F
constraint: eqt(tuplenil(H1),lock) >= F
constraint: eqt(tuplenil(H1),locker) >= F
constraint: eqt(tuplenil(H1),mcrlrecord) >= F
constraint: eqt(tuplenil(H1),ok) >= F
constraint: eqt(tuplenil(H1),pending) >= F
constraint: eqt(tuplenil(H1),release) >= F
constraint: eqt(tuplenil(H1),request) >= F
constraint: eqt(tuplenil(H1),resource) >= F
constraint: eqt(tuplenil(H1),tag) >= F
constraint: eqt(tuplenil(H1),true) >= F
constraint: eqt(a,nil) >= F
constraint: eqt(a,undefined) >= F
constraint: eqt(a,pid(N2)) >= F
constraint: eqt(a,int(N2)) >= F
constraint: eqt(a,cons(H2,T2)) >= F
constraint: eqt(a,tuple(H2,T2)) >= F
constraint: eqt(a,tuplenil(H2)) >= F
constraint: eqt(a,a) >= T
constraint: eqt(a,excl) >= F
constraint: eqt(a,false) >= F
constraint: eqt(a,lock) >= F
constraint: eqt(a,locker) >= F
constraint: eqt(a,mcrlrecord) >= F
constraint: eqt(a,ok) >= F
constraint: eqt(a,pending) >= F
constraint: eqt(a,release) >= F
constraint: eqt(a,request) >= F
constraint: eqt(a,resource) >= F
constraint: eqt(a,tag) >= F
constraint: eqt(a,true) >= F
constraint: eqt(excl,eqt(false,int(N2))) >= F
constraint: eqt(excl,nil) >= F
constraint: eqt(excl,undefined) >= F
constraint: eqt(excl,pid(N2)) >= F
constraint: eqt(excl,a) >= F
constraint: eqt(excl,excl) >= T
constraint: eqt(excl,false) >= F
constraint: eqt(excl,lock) >= F
constraint: eqt(excl,locker) >= F
constraint: eqt(excl,mcrlrecord) >= F
constraint: eqt(excl,ok) >= F
constraint: eqt(excl,pending) >= F
constraint: eqt(excl,release) >= F
constraint: eqt(excl,request) >= F
constraint: eqt(excl,resource) >= F
constraint: eqt(excl,tag) >= F
constraint: eqt(excl,true) >= F
constraint: eqt(false,cons(H2,T2)) >= F
constraint: eqt(false,tuple(H2,T2)) >= F
constraint: eqt(false,tuplenil(H2)) >= F
constraint: eqt(lock,nil) >= F
constraint: eqt(lock,undefined) >= F
constraint: eqt(lock,pid(N2)) >= F
constraint: eqt(lock,int(N2)) >= F
constraint: eqt(lock,cons(H2,T2)) >= F
constraint: eqt(lock,tuple(H2,T2)) >= F
constraint: eqt(lock,tuplenil(H2)) >= F
constraint: eqt(lock,a) >= F
constraint: eqt(lock,excl) >= F
constraint: eqt(lock,false) >= F
constraint: eqt(lock,lock) >= T
constraint: eqt(lock,locker) >= F
constraint: eqt(lock,mcrlrecord) >= F
constraint: eqt(lock,ok) >= F
constraint: eqt(lock,pending) >= F
constraint: eqt(lock,release) >= F
constraint: eqt(lock,request) >= F
constraint: eqt(lock,resource) >= F
constraint: eqt(lock,tag) >= F
constraint: eqt(lock,true) >= F
constraint: eqt(locker,nil) >= F
constraint: eqt(locker,undefined) >= F
constraint: eqt(locker,pid(N2)) >= F
constraint: eqt(locker,int(N2)) >= F
constraint: eqt(locker,cons(H2,T2)) >= F
constraint: eqt(locker,tuple(H2,T2)) >= F
constraint: eqt(locker,tuplenil(H2)) >= F
constraint: eqt(locker,a) >= F
constraint: eqt(locker,excl) >= F
constraint: eqt(locker,false) >= F
constraint: eqt(locker,lock) >= F
constraint: eqt(locker,locker) >= T
constraint: eqt(locker,mcrlrecord) >= F
constraint: eqt(locker,ok) >= F
constraint: eqt(locker,pending) >= F
constraint: eqt(locker,release) >= F
constraint: eqt(locker,request) >= F
constraint: eqt(locker,resource) >= F
constraint: eqt(locker,tag) >= F
constraint: eqt(locker,true) >= F
constraint: eqt(mcrlrecord,nil) >= F
constraint: eqt(mcrlrecord,a) >= F
constraint: eqt(mcrlrecord,excl) >= F
constraint: eqt(mcrlrecord,false) >= F
constraint: eqt(mcrlrecord,lock) >= F
constraint: eqt(mcrlrecord,locker) >= F
constraint: eqt(mcrlrecord,mcrlrecord) >= T
constraint: eqt(mcrlrecord,ok) >= F
constraint: eqt(mcrlrecord,pending) >= F
constraint: eqt(mcrlrecord,release) >= F
constraint: eqt(mcrlrecord,request) >= F
constraint: eqt(mcrlrecord,resource) >= F
constraint: eqt(ok,undefined) >= F
constraint: eqt(ok,pid(N2)) >= F
constraint: eqt(ok,int(N2)) >= F
constraint: eqt(ok,cons(H2,T2)) >= F
constraint: eqt(ok,tuple(H2,T2)) >= F
constraint: eqt(ok,tuplenil(H2)) >= F
constraint: eqt(ok,resource) >= F
constraint: eqt(ok,tag) >= F
constraint: eqt(ok,true) >= F
constraint: eqt(pending,nil) >= F
constraint: eqt(pending,undefined) >= F
constraint: eqt(pending,pid(N2)) >= F
constraint: eqt(pending,int(N2)) >= F
constraint: eqt(pending,cons(H2,T2)) >= F
constraint: eqt(pending,tuple(H2,T2)) >= F
constraint: eqt(pending,tuplenil(H2)) >= F
constraint: eqt(pending,a) >= F
constraint: eqt(pending,excl) >= F
constraint: eqt(pending,false) >= F
constraint: eqt(pending,lock) >= F
constraint: eqt(pending,locker) >= F
constraint: eqt(pending,mcrlrecord) >= F
constraint: eqt(pending,ok) >= F
constraint: eqt(pending,pending) >= T
constraint: eqt(pending,release) >= F
constraint: eqt(pending,request) >= F
constraint: eqt(pending,resource) >= F
constraint: eqt(pending,tag) >= F
constraint: eqt(pending,true) >= F
constraint: eqt(release,nil) >= F
constraint: eqt(release,a) >= F
constraint: eqt(release,excl) >= F
constraint: eqt(release,false) >= F
constraint: eqt(release,lock) >= F
constraint: eqt(release,locker) >= F
constraint: eqt(release,mcrlrecord) >= F
constraint: eqt(release,ok) >= F
constraint: eqt(request,undefined) >= F
constraint: eqt(request,pid(N2)) >= F
constraint: eqt(request,int(N2)) >= F
constraint: eqt(request,cons(H2,T2)) >= F
constraint: eqt(request,tuple(H2,T2)) >= F
constraint: eqt(request,tuplenil(H2)) >= F
constraint: eqt(request,mcrlrecord) >= F
constraint: eqt(request,ok) >= F
constraint: eqt(request,pending) >= F
constraint: eqt(request,release) >= F
constraint: eqt(request,request) >= T
constraint: eqt(request,resource) >= F
constraint: eqt(request,tag) >= F
constraint: eqt(request,true) >= F
constraint: eqt(resource,nil) >= F
constraint: eqt(resource,undefined) >= F
constraint: eqt(resource,pid(N2)) >= F
constraint: eqt(resource,int(N2)) >= F
constraint: eqt(resource,cons(H2,T2)) >= F
constraint: eqt(resource,tuple(H2,T2)) >= F
constraint: eqt(resource,tuplenil(H2)) >= F
constraint: eqt(resource,a) >= F
constraint: eqt(resource,excl) >= F
constraint: eqt(resource,false) >= F
constraint: eqt(resource,lock) >= F
constraint: eqt(resource,locker) >= F
constraint: eqt(resource,mcrlrecord) >= F
constraint: eqt(resource,ok) >= F
constraint: eqt(resource,pending) >= F
constraint: eqt(resource,release) >= F
constraint: eqt(resource,request) >= F
constraint: eqt(resource,resource) >= T
constraint: eqt(resource,tag) >= F
constraint: eqt(resource,true) >= F
constraint: eqt(tag,nil) >= F
constraint: eqt(tag,undefined) >= F
constraint: eqt(tag,pid(N2)) >= F
constraint: eqt(tag,int(N2)) >= F
constraint: eqt(tag,cons(H2,T2)) >= F
constraint: eqt(tag,tuple(H2,T2)) >= F
constraint: eqt(tag,tuplenil(H2)) >= F
constraint: eqt(tag,a) >= F
constraint: eqt(tag,excl) >= F
constraint: eqt(tag,false) >= F
constraint: eqt(tag,lock) >= F
constraint: eqt(tag,locker) >= F
constraint: eqt(tag,mcrlrecord) >= F
constraint: eqt(tag,ok) >= F
constraint: eqt(tag,pending) >= F
constraint: eqt(tag,release) >= F
constraint: eqt(tag,request) >= F
constraint: eqt(tag,resource) >= F
constraint: eqt(tag,tag) >= T
constraint: eqt(tag,true) >= F
constraint: eqt(true,nil) >= F
constraint: eqt(true,undefined) >= F
constraint: eqt(true,pid(N2)) >= F
constraint: eqt(true,int(N2)) >= F
constraint: eqt(true,cons(H2,T2)) >= F
constraint: eqt(true,tuple(H2,T2)) >= F
constraint: eqt(true,tuplenil(H2)) >= F
constraint: eqt(true,a) >= F
constraint: eqt(true,excl) >= F
constraint: eqt(true,false) >= F
constraint: eqt(true,lock) >= F
constraint: eqt(true,locker) >= F
constraint: eqt(true,mcrlrecord) >= F
constraint: eqt(true,ok) >= F
constraint: eqt(true,pending) >= F
constraint: eqt(true,release) >= F
constraint: eqt(true,request) >= F
constraint: eqt(true,resource) >= F
constraint: eqt(true,tag) >= F
constraint: eqt(true,true) >= T
constraint: element(int(s(s(N1))),tuple(T1,T2)) >= element(int(s(N1)),T2)
constraint: element(int(s(0)),tuple(T1,T2)) >= T1
constraint: element(int(s(0)),tuplenil(T1)) >= T1
constraint: record_new(lock) >= tuple(mcrlrecord,
                                 tuple(lock,
                                  tuple(undefined,tuple(nil,tuplenil(nil)))))
constraint: record_extract(tuple(mcrlrecord,
                            tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,resource) >= tuple(mcrlrecord,
                                tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
constraint: record_update(tuple(mcrlrecord,
                           tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),
             lock,pending,NewF) >= tuple(mcrlrecord,
                                    tuple(lock,
                                     tuple(F0,tuple(F1,tuplenil(NewF)))))
constraint: record_updates(Record,Name,nil) >= Record
constraint: record_updates(Record,Name,
             cons(tuple(Field,tuplenil(NewF)),Fields)) >= record_updates(
                                                           record_update(
                                                            Record,Name,
                                                            Field,NewF),
                                                           Name,Fields)
constraint: locker2_map_promote_pending(nil,Pending) >= nil
constraint: locker2_map_promote_pending(cons(Lock,Locks),Pending) >= 
cons(locker2_promote_pending(Lock,Pending),
 locker2_map_promote_pending(Locks,Pending))
constraint: locker2_promote_pending(Lock,Client) >= case0(Client,Lock,
                                                     record_extract(Lock,
                                                      lock,pending))
constraint: locker2_map_claim_lock(nil,Resources,Client) >= nil
constraint: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) >= 
cons(locker2_claim_lock(Lock,Resources,Client),
 locker2_map_claim_lock(Locks,Resources,Client))
constraint: locker2_map_add_pending(nil,Resources,Client) >= nil
constraint: case0(Client,Lock,cons(Client,Pendings)) >= record_updates(
                                                         Lock,lock,
                                                         cons(tuple(excl,
                                                               tuplenil(Client)),
                                                          cons(tuple(
                                                                pending,
                                                                tuplenil(
                                                                 Pendings)),
                                                           nil)))
constraint: case0(Client,Lock,MCRLFree0) >= Lock
constraint: subtract(List,nil) >= List
constraint: subtract(List,cons(Head,Tail)) >= subtract(delete(Head,List),Tail)
constraint: locker2_remove_pending(Lock,Client) >= record_updates(Lock,
                                                    lock,
                                                    cons(tuple(pending,
                                                          tuplenil(subtract(
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                                    cons(
                                                                    Client,
                                                                    nil)))),
                                                     nil))
constraint: case1(Client,Resources,Lock,false) >= Lock
constraint: case1(Client,Resources,Lock,true) >= record_updates(Lock,
                                                  lock,
                                                  cons(tuple(pending,
                                                        tuplenil(append(
                                                                  record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   pending),
                                                                  cons(
                                                                   Client,
                                                                   nil)))),
                                                   nil))
constraint: member(E,nil) >= false
constraint: member(E,cons(Head,Tail)) >= case9(Tail,Head,E,equal(E,Head))
constraint: locker2_add_pending(Lock,Resources,Client) >= case1(Client,
                                                           Resources,
                                                           Lock,
                                                           member(record_extract(
                                                                   Lock,
                                                                   lock,
                                                                   resource),
                                                            Resources))
constraint: append(cons(Head,Tail),List) >= cons(Head,append(Tail,List))
constraint: case2(Client,Lock,true) >= record_updates(Lock,lock,
                                        cons(tuple(excllock,excl),nil))
constraint: gen_modtageq(Client1,Client2) >= equal(Client1,Client2)
constraint: locker2_release_lock(Lock,Client) >= case2(Client,Lock,
                                                  gen_modtageq(Client,
                                                   record_extract(Lock,
                                                    lock,excl)))
constraint: case4(Client,Lock,MCRLFree1) >= false
constraint: locker2_obtainables(nil,Client) >= true
constraint: locker2_obtainables(cons(Lock,Locks),Client) >= case5(Client,
                                                             Locks,Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))
constraint: case5(Client,Locks,Lock,false) >= locker2_obtainables(Locks,Client)
constraint: case5(Client,Locks,Lock,true) >= andt(locker2_obtainable(
                                                   Lock,Client),
                                              locker2_obtainables(Locks,Client))
constraint: locker2_check_available(Resource,nil) >= false
constraint: locker2_check_available(Resource,cons(Lock,Locks)) >= case6(
                                                                   Locks,
                                                                   Lock,
                                                                   Resource,
                                                                   equal(
                                                                    Resource,
                                                                    record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource)))
constraint: case6(Locks,Lock,Resource,false) >= locker2_check_available(
                                                 Resource,Locks)
constraint: case6(Locks,Lock,Resource,true) >= andt(equal(record_extract(
                                                           Lock,lock,
                                                           excl),nil),
                                                equal(record_extract(
                                                       Lock,lock,pending),
                                                 nil))
constraint: locker2_check_availables(nil,Locks) >= true
constraint: locker2_check_availables(cons(Resource,Resources),Locks) >= 
andt(locker2_check_available(Resource,Locks),
 locker2_check_availables(Resources,Locks))
constraint: locker2_adduniq(nil,List) >= List
constraint: delete(E,nil) >= nil
constraint: delete(E,cons(Head,Tail)) >= case8(Tail,Head,E,equal(E,Head))
constraint: case8(Tail,Head,E,false) >= cons(Head,delete(E,Tail))
constraint: case8(Tail,Head,E,true) >= Tail
constraint: gen_tag(Pid) >= tuple(Pid,tuplenil(tag))
constraint: case9(Tail,Head,E,false) >= member(E,Tail)
constraint: case9(Tail,Head,E,true) >= true
constraint: eqs(empty,empty) >= T
constraint: eqs(empty,stack(E2,S2)) >= F
constraint: eqs(stack(E1,S1),empty) >= F
constraint: eqs(stack(E1,S1),stack(E2,S2)) >= and(eqt(E1,E2),eqs(S1,S2))
constraint: pushs(E1,S1) >= stack(E1,S1)
constraint: pops(stack(E1,S1)) >= S1
constraint: tops(stack(E1,S1)) >= E1
constraint: istops(E1,empty) >= F
constraint: istops(E1,stack(E2,S1)) >= eqt(E1,E2)
constraint: eqc(nocalls,nocalls) >= T
constraint: eqc(nocalls,calls(E2,S2,CS2)) >= F
constraint: eqc(calls(E1,S1,CS1),nocalls) >= F
constraint: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) >= and(eqt(E1,E2),
                                                       and(eqs(S1,S2),
                                                        eqc(CS1,CS2)))
constraint: push(E1,E2,nocalls) >= calls(E1,stack(E2,empty),nocalls)
constraint: push(E1,E2,calls(E3,S1,CS1)) >= push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
constraint: push1(E1,E2,E3,S1,CS1,T) >= calls(E3,pushs(E2,S1),CS1)
constraint: Marked_eqt(tuplenil(H1),tuplenil(H2)) >= Marked_eqt(H1,H2)
APPLY CRITERIA (Graph splitting)
Found 0 components:
SOLVED
{
 
TRS termination of:
[1] or(T,T) -> T
[2] or(F,T) -> T
[3] or(T,F) -> T
[4] or(F,F) -> F
[5] and(T,B) -> B
[6] and(B,T) -> B
[7] and(F,B) -> F
[8] and(B,F) -> F
[9] imp(T,B) -> B
[10] imp(F,B) -> T
[11] not(T) -> F
[12] not(F) -> T
[13] if(T,B1,B2) -> B1
[14] if(F,B1,B2) -> B2
[15] eq(T,T) -> T
[16] eq(F,F) -> T
[17] eq(T,F) -> F
[18] eq(F,T) -> F
[19] eqt(nil,undefined) -> F
[20] eqt(nil,pid(N2)) -> F
[21] eqt(nil,int(N2)) -> F
[22] eqt(nil,cons(H2,T2)) -> F
[23] eqt(nil,tuple(H2,T2)) -> F
[24] eqt(nil,tuplenil(H2)) -> F
[25] eqt(a,nil) -> F
[26] eqt(a,a) -> T
[27] eqt(a,excl) -> F
[28] eqt(a,false) -> F
[29] eqt(a,lock) -> F
[30] eqt(a,locker) -> F
[31] eqt(a,mcrlrecord) -> F
[32] eqt(a,ok) -> F
[33] eqt(a,pending) -> F
[34] eqt(a,release) -> F
[35] eqt(a,request) -> F
[36] eqt(a,resource) -> F
[37] eqt(a,tag) -> F
[38] eqt(a,true) -> F
[39] eqt(a,undefined) -> F
[40] eqt(a,pid(N2)) -> F
[41] eqt(a,int(N2)) -> F
[42] eqt(a,cons(H2,T2)) -> F
[43] eqt(a,tuple(H2,T2)) -> F
[44] eqt(a,tuplenil(H2)) -> F
[45] eqt(excl,nil) -> F
[46] eqt(excl,a) -> F
[47] eqt(excl,excl) -> T
[48] eqt(excl,false) -> F
[49] eqt(excl,lock) -> F
[50] eqt(excl,locker) -> F
[51] eqt(excl,mcrlrecord) -> F
[52] eqt(excl,ok) -> F
[53] eqt(excl,pending) -> F
[54] eqt(excl,release) -> F
[55] eqt(excl,request) -> F
[56] eqt(excl,resource) -> F
[57] eqt(excl,tag) -> F
[58] eqt(excl,true) -> F
[59] eqt(excl,undefined) -> F
[60] eqt(excl,pid(N2)) -> F
[61] eqt(excl,eqt(false,int(N2))) -> F
[62] eqt(false,cons(H2,T2)) -> F
[63] eqt(false,tuple(H2,T2)) -> F
[64] eqt(false,tuplenil(H2)) -> F
[65] eqt(lock,nil) -> F
[66] eqt(lock,a) -> F
[67] eqt(lock,excl) -> F
[68] eqt(lock,false) -> F
[69] eqt(lock,lock) -> T
[70] eqt(lock,locker) -> F
[71] eqt(lock,mcrlrecord) -> F
[72] eqt(lock,ok) -> F
[73] eqt(lock,pending) -> F
[74] eqt(lock,release) -> F
[75] eqt(lock,request) -> F
[76] eqt(lock,resource) -> F
[77] eqt(lock,tag) -> F
[78] eqt(lock,true) -> F
[79] eqt(lock,undefined) -> F
[80] eqt(lock,pid(N2)) -> F
[81] eqt(lock,int(N2)) -> F
[82] eqt(lock,cons(H2,T2)) -> F
[83] eqt(lock,tuple(H2,T2)) -> F
[84] eqt(lock,tuplenil(H2)) -> F
[85] eqt(locker,nil) -> F
[86] eqt(locker,a) -> F
[87] eqt(locker,excl) -> F
[88] eqt(locker,false) -> F
[89] eqt(locker,lock) -> F
[90] eqt(locker,locker) -> T
[91] eqt(locker,mcrlrecord) -> F
[92] eqt(locker,ok) -> F
[93] eqt(locker,pending) -> F
[94] eqt(locker,release) -> F
[95] eqt(locker,request) -> F
[96] eqt(locker,resource) -> F
[97] eqt(locker,tag) -> F
[98] eqt(locker,true) -> F
[99] eqt(locker,undefined) -> F
[100] eqt(locker,pid(N2)) -> F
[101] eqt(locker,int(N2)) -> F
[102] eqt(locker,cons(H2,T2)) -> F
[103] eqt(locker,tuple(H2,T2)) -> F
[104] eqt(locker,tuplenil(H2)) -> F
[105] eqt(mcrlrecord,nil) -> F
[106] eqt(mcrlrecord,a) -> F
[107] eqt(mcrlrecord,excl) -> F
[108] eqt(mcrlrecord,false) -> F
[109] eqt(mcrlrecord,lock) -> F
[110] eqt(mcrlrecord,locker) -> F
[111] eqt(mcrlrecord,mcrlrecord) -> T
[112] eqt(mcrlrecord,ok) -> F
[113] eqt(mcrlrecord,pending) -> F
[114] eqt(mcrlrecord,release) -> F
[115] eqt(mcrlrecord,request) -> F
[116] eqt(mcrlrecord,resource) -> F
[117] eqt(ok,resource) -> F
[118] eqt(ok,tag) -> F
[119] eqt(ok,true) -> F
[120] eqt(ok,undefined) -> F
[121] eqt(ok,pid(N2)) -> F
[122] eqt(ok,int(N2)) -> F
[123] eqt(ok,cons(H2,T2)) -> F
[124] eqt(ok,tuple(H2,T2)) -> F
[125] eqt(ok,tuplenil(H2)) -> F
[126] eqt(pending,nil) -> F
[127] eqt(pending,a) -> F
[128] eqt(pending,excl) -> F
[129] eqt(pending,false) -> F
[130] eqt(pending,lock) -> F
[131] eqt(pending,locker) -> F
[132] eqt(pending,mcrlrecord) -> F
[133] eqt(pending,ok) -> F
[134] eqt(pending,pending) -> T
[135] eqt(pending,release) -> F
[136] eqt(pending,request) -> F
[137] eqt(pending,resource) -> F
[138] eqt(pending,tag) -> F
[139] eqt(pending,true) -> F
[140] eqt(pending,undefined) -> F
[141] eqt(pending,pid(N2)) -> F
[142] eqt(pending,int(N2)) -> F
[143] eqt(pending,cons(H2,T2)) -> F
[144] eqt(pending,tuple(H2,T2)) -> F
[145] eqt(pending,tuplenil(H2)) -> F
[146] eqt(release,nil) -> F
[147] eqt(release,a) -> F
[148] eqt(release,excl) -> F
[149] eqt(release,false) -> F
[150] eqt(release,lock) -> F
[151] eqt(release,locker) -> F
[152] eqt(release,mcrlrecord) -> F
[153] eqt(release,ok) -> F
[154] eqt(request,mcrlrecord) -> F
[155] eqt(request,ok) -> F
[156] eqt(request,pending) -> F
[157] eqt(request,release) -> F
[158] eqt(request,request) -> T
[159] eqt(request,resource) -> F
[160] eqt(request,tag) -> F
[161] eqt(request,true) -> F
[162] eqt(request,undefined) -> F
[163] eqt(request,pid(N2)) -> F
[164] eqt(request,int(N2)) -> F
[165] eqt(request,cons(H2,T2)) -> F
[166] eqt(request,tuple(H2,T2)) -> F
[167] eqt(request,tuplenil(H2)) -> F
[168] eqt(resource,nil) -> F
[169] eqt(resource,a) -> F
[170] eqt(resource,excl) -> F
[171] eqt(resource,false) -> F
[172] eqt(resource,lock) -> F
[173] eqt(resource,locker) -> F
[174] eqt(resource,mcrlrecord) -> F
[175] eqt(resource,ok) -> F
[176] eqt(resource,pending) -> F
[177] eqt(resource,release) -> F
[178] eqt(resource,request) -> F
[179] eqt(resource,resource) -> T
[180] eqt(resource,tag) -> F
[181] eqt(resource,true) -> F
[182] eqt(resource,undefined) -> F
[183] eqt(resource,pid(N2)) -> F
[184] eqt(resource,int(N2)) -> F
[185] eqt(resource,cons(H2,T2)) -> F
[186] eqt(resource,tuple(H2,T2)) -> F
[187] eqt(resource,tuplenil(H2)) -> F
[188] eqt(tag,nil) -> F
[189] eqt(tag,a) -> F
[190] eqt(tag,excl) -> F
[191] eqt(tag,false) -> F
[192] eqt(tag,lock) -> F
[193] eqt(tag,locker) -> F
[194] eqt(tag,mcrlrecord) -> F
[195] eqt(tag,ok) -> F
[196] eqt(tag,pending) -> F
[197] eqt(tag,release) -> F
[198] eqt(tag,request) -> F
[199] eqt(tag,resource) -> F
[200] eqt(tag,tag) -> T
[201] eqt(tag,true) -> F
[202] eqt(tag,undefined) -> F
[203] eqt(tag,pid(N2)) -> F
[204] eqt(tag,int(N2)) -> F
[205] eqt(tag,cons(H2,T2)) -> F
[206] eqt(tag,tuple(H2,T2)) -> F
[207] eqt(tag,tuplenil(H2)) -> F
[208] eqt(true,nil) -> F
[209] eqt(true,a) -> F
[210] eqt(true,excl) -> F
[211] eqt(true,false) -> F
[212] eqt(true,lock) -> F
[213] eqt(true,locker) -> F
[214] eqt(true,mcrlrecord) -> F
[215] eqt(true,ok) -> F
[216] eqt(true,pending) -> F
[217] eqt(true,release) -> F
[218] eqt(true,request) -> F
[219] eqt(true,resource) -> F
[220] eqt(true,tag) -> F
[221] eqt(true,true) -> T
[222] eqt(true,undefined) -> F
[223] eqt(true,pid(N2)) -> F
[224] eqt(true,int(N2)) -> F
[225] eqt(true,cons(H2,T2)) -> F
[226] eqt(true,tuple(H2,T2)) -> F
[227] eqt(true,tuplenil(H2)) -> F
[228] eqt(undefined,nil) -> F
[229] eqt(undefined,a) -> F
[230] eqt(undefined,tuplenil(H2)) -> F
[231] eqt(pid(N1),nil) -> F
[232] eqt(pid(N1),a) -> F
[233] eqt(pid(N1),excl) -> F
[234] eqt(pid(N1),false) -> F
[235] eqt(pid(N1),lock) -> F
[236] eqt(pid(N1),locker) -> F
[237] eqt(pid(N1),mcrlrecord) -> F
[238] eqt(pid(N1),ok) -> F
[239] eqt(pid(N1),pending) -> F
[240] eqt(pid(N1),release) -> F
[241] eqt(pid(N1),request) -> F
[242] eqt(pid(N1),resource) -> F
[243] eqt(pid(N1),tag) -> F
[244] eqt(pid(N1),true) -> F
[245] eqt(pid(N1),undefined) -> F
[246] eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
[247] eqt(pid(N1),int(N2)) -> F
[248] eqt(pid(N1),cons(H2,T2)) -> F
[249] eqt(pid(N1),tuple(H2,T2)) -> F
[250] eqt(pid(N1),tuplenil(H2)) -> F
[251] eqt(int(N1),nil) -> F
[252] eqt(int(N1),a) -> F
[253] eqt(int(N1),excl) -> F
[254] eqt(int(N1),false) -> F
[255] eqt(int(N1),lock) -> F
[256] eqt(int(N1),locker) -> F
[257] eqt(int(N1),mcrlrecord) -> F
[258] eqt(int(N1),ok) -> F
[259] eqt(int(N1),pending) -> F
[260] eqt(int(N1),release) -> F
[261] eqt(int(N1),request) -> F
[262] eqt(int(N1),resource) -> F
[263] eqt(int(N1),tag) -> F
[264] eqt(int(N1),true) -> F
[265] eqt(int(N1),undefined) -> F
[266] eqt(cons(H1,T1),resource) -> F
[267] eqt(cons(H1,T1),tag) -> F
[268] eqt(cons(H1,T1),true) -> F
[269] eqt(cons(H1,T1),undefined) -> F
[270] eqt(cons(H1,T1),pid(N2)) -> F
[271] eqt(cons(H1,T1),int(N2)) -> F
[272] eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
[273] eqt(cons(H1,T1),tuple(H2,T2)) -> F
[274] eqt(cons(H1,T1),tuplenil(H2)) -> F
[275] eqt(tuple(H1,T1),nil) -> F
[276] eqt(tuple(H1,T1),a) -> F
[277] eqt(tuple(H1,T1),excl) -> F
[278] eqt(tuple(H1,T1),false) -> F
[279] eqt(tuple(H1,T1),lock) -> F
[280] eqt(tuple(H1,T1),locker) -> F
[281] eqt(tuple(H1,T1),mcrlrecord) -> F
[282] eqt(tuple(H1,T1),ok) -> F
[283] eqt(tuple(H1,T1),pending) -> F
[284] eqt(tuple(H1,T1),release) -> F
[285] eqt(tuple(H1,T1),request) -> F
[286] eqt(tuple(H1,T1),resource) -> F
[287] eqt(tuple(H1,T1),tag) -> F
[288] eqt(tuple(H1,T1),true) -> F
[289] eqt(tuple(H1,T1),undefined) -> F
[290] eqt(tuple(H1,T1),pid(N2)) -> F
[291] eqt(tuple(H1,T1),int(N2)) -> F
[292] eqt(tuple(H1,T1),cons(H2,T2)) -> F
[293] eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
[294] eqt(tuple(H1,T1),tuplenil(H2)) -> F
[295] eqt(tuplenil(H1),nil) -> F
[296] eqt(tuplenil(H1),a) -> F
[297] eqt(tuplenil(H1),excl) -> F
[298] eqt(tuplenil(H1),false) -> F
[299] eqt(tuplenil(H1),lock) -> F
[300] eqt(tuplenil(H1),locker) -> F
[301] eqt(tuplenil(H1),mcrlrecord) -> F
[302] eqt(tuplenil(H1),ok) -> F
[303] eqt(tuplenil(H1),pending) -> F
[304] eqt(tuplenil(H1),release) -> F
[305] eqt(tuplenil(H1),request) -> F
[306] eqt(tuplenil(H1),resource) -> F
[307] eqt(tuplenil(H1),tag) -> F
[308] eqt(tuplenil(H1),true) -> F
[309] eqt(tuplenil(H1),undefined) -> F
[310] eqt(tuplenil(H1),pid(N2)) -> F
[311] eqt(tuplenil(H1),int(N2)) -> F
[312] eqt(tuplenil(H1),cons(H2,T2)) -> F
[313] eqt(tuplenil(H1),tuple(H2,T2)) -> F
[314] eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
[315] element(int(s(0)),tuplenil(T1)) -> T1
[316] element(int(s(0)),tuple(T1,T2)) -> T1
[317] element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
[318] record_new(lock) ->
 tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil)))))
[319] record_extract(tuple(mcrlrecord,
                      tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),lock,
       resource) ->
 tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(F2)))))
[320] record_update(tuple(mcrlrecord,
                     tuple(lock,tuple(F0,tuple(F1,tuplenil(F2))))),lock,
       pending,NewF) ->
 tuple(mcrlrecord,tuple(lock,tuple(F0,tuple(F1,tuplenil(NewF)))))
[321] record_updates(Record,Name,nil) -> Record
[322] record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) ->
 record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
[323] locker2_map_promote_pending(nil,Pending) -> nil
[324] locker2_map_promote_pending(cons(Lock,Locks),Pending) ->
 cons(locker2_promote_pending(Lock,Pending),
  locker2_map_promote_pending(Locks,Pending))
[325] locker2_map_claim_lock(nil,Resources,Client) -> nil
[326] locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) ->
 cons(locker2_claim_lock(Lock,Resources,Client),
  locker2_map_claim_lock(Locks,Resources,Client))
[327] locker2_map_add_pending(nil,Resources,Client) -> nil
[328] locker2_promote_pending(Lock,Client) ->
 case0(Client,Lock,record_extract(Lock,lock,pending))
[329] case0(Client,Lock,cons(Client,Pendings)) ->
 record_updates(Lock,lock,
  cons(tuple(excl,tuplenil(Client)),
   cons(tuple(pending,tuplenil(Pendings)),nil)))
[330] case0(Client,Lock,MCRLFree0) -> Lock
[331] locker2_remove_pending(Lock,Client) ->
 record_updates(Lock,lock,
  cons(tuple(pending,
        tuplenil(subtract(record_extract(Lock,lock,pending),cons(Client,nil)))),
   nil))
[332] locker2_add_pending(Lock,Resources,Client) ->
 case1(Client,Resources,Lock,
  member(record_extract(Lock,lock,resource),Resources))
[333] case1(Client,Resources,Lock,true) ->
 record_updates(Lock,lock,
  cons(tuple(pending,
        tuplenil(append(record_extract(Lock,lock,pending),cons(Client,nil)))),
   nil))
[334] case1(Client,Resources,Lock,false) -> Lock
[335] locker2_release_lock(Lock,Client) ->
 case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock,excl)))
[336] case2(Client,Lock,true) ->
 record_updates(Lock,lock,cons(tuple(excllock,excl),nil))
[337] case4(Client,Lock,MCRLFree1) -> false
[338] locker2_obtainables(nil,Client) -> true
[339] locker2_obtainables(cons(Lock,Locks),Client) ->
 case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock,pending)))
[340] case5(Client,Locks,Lock,true) ->
 andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
[341] case5(Client,Locks,Lock,false) -> locker2_obtainables(Locks,Client)
[342] locker2_check_available(Resource,nil) -> false
[343] locker2_check_available(Resource,cons(Lock,Locks)) ->
 case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock,resource)))
[344] case6(Locks,Lock,Resource,true) ->
 andt(equal(record_extract(Lock,lock,excl),nil),
  equal(record_extract(Lock,lock,pending),nil))
[345] case6(Locks,Lock,Resource,false) ->
 locker2_check_available(Resource,Locks)
[346] locker2_check_availables(nil,Locks) -> true
[347] locker2_check_availables(cons(Resource,Resources),Locks) ->
 andt(locker2_check_available(Resource,Locks),
  locker2_check_availables(Resources,Locks))
[348] locker2_adduniq(nil,List) -> List
[349] append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
[350] subtract(List,nil) -> List
[351] subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
[352] delete(E,nil) -> nil
[353] delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
[354] case8(Tail,Head,E,true) -> Tail
[355] case8(Tail,Head,E,false) -> cons(Head,delete(E,Tail))
[356] gen_tag(Pid) -> tuple(Pid,tuplenil(tag))
[357] gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
[358] member(E,nil) -> false
[359] member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
[360] case9(Tail,Head,E,true) -> true
[361] case9(Tail,Head,E,false) -> member(E,Tail)
[362] eqs(empty,empty) -> T
[363] eqs(empty,stack(E2,S2)) -> F
[364] eqs(stack(E1,S1),empty) -> F
[365] eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
[366] pushs(E1,S1) -> stack(E1,S1)
[367] pops(stack(E1,S1)) -> S1
[368] tops(stack(E1,S1)) -> E1
[369] istops(E1,empty) -> F
[370] istops(E1,stack(E2,S1)) -> eqt(E1,E2)
[371] eqc(nocalls,nocalls) -> T
[372] eqc(nocalls,calls(E2,S2,CS2)) -> F
[373] eqc(calls(E1,S1,CS1),nocalls) -> F
[374] eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) ->
 and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
[375] push(E1,E2,nocalls) -> calls(E1,stack(E2,empty),nocalls)
[376] push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
[377] push1(E1,E2,E3,S1,CS1,T) -> calls(E3,pushs(E2,S1),CS1)
 ,
 CRITERION: MDP
 [ {
      
     DP termination of:
     <Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_and(eqt(H1,H2),eqt(T1,T2))>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_and(eqt(H1,H2),eqt(T1,T2))>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
<Marked_element(int(s(s(N1))),tuple(T1,T2)) , Marked_element(int(s(N1)),T2)>
<Marked_record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) , Marked_record_updates(
                                                                    record_update(
                                                                    Record,
                                                                    Name,
                                                                    Field,
                                                                    NewF),Name,
                                                                    Fields)>
<Marked_record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) , Marked_record_update(
                                                                    Record,
                                                                    Name,Field,
                                                                    NewF)>
<Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) , Marked_locker2_promote_pending(
                                                                 Lock,
                                                                 Pending)>
<Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) , Marked_locker2_map_promote_pending(
                                                                 Locks,
                                                                 Pending)>
<Marked_locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) , Marked_locker2_map_claim_lock(
                                                                    Locks,
                                                                    Resources,
                                                                    Client)>
<Marked_locker2_promote_pending(Lock,Client) , Marked_case0(Client,Lock,
                                                record_extract(Lock,lock,
                                                 pending))>
<Marked_locker2_promote_pending(Lock,Client) , Marked_record_extract(
                                                Lock,lock,pending)>
<Marked_case0(Client,Lock,cons(Client,Pendings)) , Marked_record_updates(
                                                    Lock,lock,
                                                    cons(tuple(excl,
                                                          tuplenil(Client)),
                                                     cons(tuple(pending,
                                                           tuplenil(Pendings)),
                                                      nil)))>
<Marked_locker2_remove_pending(Lock,Client) , Marked_record_updates(Lock,
                                               lock,
                                               cons(tuple(pending,
                                                     tuplenil(subtract(
                                                               record_extract(
                                                                Lock,
                                                                lock,
                                                                pending),
                                                               cons(Client,nil)))
                                                      ),nil))>
<Marked_locker2_remove_pending(Lock,Client) , Marked_subtract(record_extract(
                                                               Lock,lock,
                                                               pending),
                                               cons(Client,nil))>
<Marked_locker2_remove_pending(Lock,Client) , Marked_record_extract(Lock,
                                               lock,pending)>
<Marked_locker2_add_pending(Lock,Resources,Client) , Marked_case1(Client,
                                                      Resources,Lock,
                                                      member(record_extract(
                                                              Lock,lock,
                                                              resource),
                                                       Resources))>
<Marked_locker2_add_pending(Lock,Resources,Client) , Marked_member(record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    resource),
                                                      Resources)>
<Marked_locker2_add_pending(Lock,Resources,Client) , Marked_record_extract(
                                                      Lock,lock,resource)>
<Marked_case1(Client,Resources,Lock,true) , Marked_record_updates(Lock,
                                             lock,
                                             cons(tuple(pending,
                                                   tuplenil(append(record_extract(
                                                                    Lock,
                                                                    lock,
                                                                    pending),
                                                             cons(Client,nil)))),
                                              nil))>
<Marked_case1(Client,Resources,Lock,true) , Marked_append(record_extract(
                                                           Lock,lock,
                                                           pending),
                                             cons(Client,nil))>
<Marked_case1(Client,Resources,Lock,true) , Marked_record_extract(Lock,
                                             lock,pending)>
<Marked_locker2_release_lock(Lock,Client) , Marked_case2(Client,Lock,
                                             gen_modtageq(Client,
                                              record_extract(Lock,lock,excl)))>
<Marked_locker2_release_lock(Lock,Client) , Marked_gen_modtageq(Client,
                                             record_extract(Lock,lock,excl))>
<Marked_locker2_release_lock(Lock,Client) , Marked_record_extract(Lock,
                                             lock,excl)>
<Marked_case2(Client,Lock,true) , Marked_record_updates(Lock,lock,
                                   cons(tuple(excllock,excl),nil))>
<Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(Client,
                                                        Locks,Lock,
                                                        member(Client,
                                                         record_extract(
                                                          Lock,lock,pending)))>
<Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_member(
                                                        Client,
                                                        record_extract(
                                                         Lock,lock,pending))>
<Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_record_extract(
                                                        Lock,lock,pending)>
<Marked_case5(Client,Locks,Lock,true) , Marked_locker2_obtainables(Locks,
                                         Client)>
<Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(Locks,
                                          Client)>
<Marked_locker2_check_available(Resource,cons(Lock,Locks)) , Marked_case6(
                                                              Locks,Lock,
                                                              Resource,
                                                              equal(Resource,
                                                               record_extract(
                                                                Lock,
                                                                lock,
                                                                resource)))>
<Marked_locker2_check_available(Resource,cons(Lock,Locks)) , Marked_record_extract(
                                                              Lock,lock,
                                                              resource)>
<Marked_case6(Locks,Lock,Resource,true) , Marked_record_extract(Lock,lock,excl)>
<Marked_case6(Locks,Lock,Resource,true) , Marked_record_extract(Lock,
                                           lock,pending)>
<Marked_case6(Locks,Lock,Resource,false) , Marked_locker2_check_available(
                                            Resource,Locks)>
<Marked_locker2_check_availables(cons(Resource,Resources),Locks) , Marked_locker2_check_available(
                                                                    Resource,
                                                                    Locks)>
<Marked_locker2_check_availables(cons(Resource,Resources),Locks) , Marked_locker2_check_availables(
                                                                    Resources,
                                                                    Locks)>
<Marked_append(cons(Head,Tail),List) , Marked_append(Tail,List)>
<Marked_subtract(List,cons(Head,Tail)) , Marked_subtract(delete(Head,List),
                                          Tail)>
<Marked_subtract(List,cons(Head,Tail)) , Marked_delete(Head,List)>
<Marked_delete(E,cons(Head,Tail)) , Marked_case8(Tail,Head,E,equal(E,Head))>
<Marked_case8(Tail,Head,E,false) , Marked_delete(E,Tail)>
<Marked_member(E,cons(Head,Tail)) , Marked_case9(Tail,Head,E,equal(E,Head))>
<Marked_case9(Tail,Head,E,false) , Marked_member(E,Tail)>
<Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_and(eqt(E1,E2),eqs(S1,S2))>
<Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_eqt(E1,E2)>
<Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_eqs(S1,S2)>
<Marked_istops(E1,stack(E2,S1)) , Marked_eqt(E1,E2)>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_and(eqt(E1,E2),
                                                  and(eqs(S1,S2),eqc(CS1,CS2)))>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqt(E1,E2)>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_and(eqs(S1,S2),
                                                  eqc(CS1,CS2))>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqs(S1,S2)>
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqc(CS1,CS2)>
<Marked_push(E1,E2,calls(E3,S1,CS1)) , Marked_push1(E1,E2,E3,S1,CS1,eqt(E1,E3))>
<Marked_push(E1,E2,calls(E3,S1,CS1)) , Marked_eqt(E1,E3)>
<Marked_push1(E1,E2,E3,S1,CS1,T) , Marked_pushs(E2,S1)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_element(int(s(s(N1))),tuple(T1,T2)) , Marked_element(int(s(N1)),
                                                    T2)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 3*X0 + 0; 
 [ record_new ] (X0) = 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 3*X1 + 1*X2 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 1*X0 + 2*X1 + 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 2*X1 + 2*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ stack ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 1 + 3*X0 + 3*X1 + 3*X2 + 0; 
 [ int ] (X0) = 1*X0 + 0; 
 [ push ] (X0,X1,X2) = 2 + 3*X0 + 3*X1 + 2*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 2 + 1*X0 + 3*X1 + 3*X2 + 0; 
 [ true ] () = 1 + 0; 
 [ locker2_check_availables ] (X0,X1) = 2 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1 + 1*X0 + 2*X2 + 2*X3 + 0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 1 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 0; 
 [ if ] (X0,X1,X2) = 3 + 2*X0 + 3*X1 + 3*X2 + 0; 
 [ pops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 2*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 1 + 2*X1 + 1*X2 + 2*X3 + 0; 
 [ tuple ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 2 + 2*X0 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 1*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 3*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 3*X0 + 3*X1 + 0; 
 [ case0 ] (X0,X1,X2) = 1 + 1*X1 + 2*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 2*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 1 + 3*X0 + 0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 1 + 1*X0 + 0; 
 [ Marked_element ] (X0,X1) = 1*X0 + 0; 
 [ cons ] (X0,X1) = 1 + 1*X0 + 2*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 2 + 3*X0 + 3*X1 + 2*X2 + 2*X3 + 3*X4 + 0; 
 [ member ] (X0,X1) = 0; 
 [ element ] (X0,X1) = 2 + 1*X0 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 2 + 2*X0 + 3*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 2 + 2*X0 + 1*X1 + 3*X2 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 3 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 2*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 1 + 2*X0 + 1*X1 + 0; 
 ]} 
{
 
DP termination of:
<Marked_locker2_map_promote_pending(cons(Lock,Locks),Pending) , Marked_locker2_map_promote_pending(
                                                                 Locks,
                                                                 Pending)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 1*X0 + 0; 
 [ record_new ] (X0) = 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 1 + 3*X1 + 1*X2 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 2*X1 + 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 2*X1 + 2*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 2*X1 + 0; 
 [ stack ] (X0,X1) = 1*X0 + 2*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 3 + 2*X0 + 2*X1 + 3*X2 + 0; 
 [ int ] (X0) = 2*X0 + 0; 
 [ push ] (X0,X1,X2) = 2 + 3*X0 + 3*X1 + 2*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 3 + 1*X0 + 3*X1 + 3*X2 + 0; 
 [ true ] () = 1 + 0; 
 [ locker2_check_availables ] (X0,X1) = 1 + 2*X0 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X0 + 1*X3 + 0; 
 [ false ] () = 2 + 0; 
 [ locker2_release_lock ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ Marked_locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 3 + 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 2*X0 + 2*X3 + 0; 
 [ if ] (X0,X1,X2) = 3 + 2*X0 + 2*X1 + 2*X2 + 0; 
 [ pops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 1*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 1 + 0; 
 [ tuple ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 2 + 3*X0 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 2*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 2*X0 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 3*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ case0 ] (X0,X1,X2) = 2 + 1*X1 + 1*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 2 + 2*X1 + 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 2*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 2 + 3*X0 + 0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 1 + 0; 
 [ cons ] (X0,X1) = 2 + 1*X0 + 1*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 2 + 3*X0 + 3*X1 + 2*X2 + 2*X3 + 3*X4 + 0; 
 [ member ] (X0,X1) = 2 + 0; 
 [ element ] (X0,X1) = 2 + 1*X0 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 2 + 2*X0 + 3*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 2*X0 + 1*X1 + 2*X2 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 3 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 1 + 0; 
 [ tuplenil ] (X0) = 1*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 1*X0 + 1*X1 + 1*X3 + 0; 
 ]} 
{
 
DP termination of:
<Marked_locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) , Marked_locker2_map_claim_lock(
                                                                    Locks,
                                                                    Resources,
                                                                    Client)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 2*X0 + 0; 
 [ record_new ] (X0) = 2 + 2*X0 + 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 1 + 3*X1 + 3*X2 + 0; 
 [ eqt ] (X0,X1) = 2*X1 + 0; 
 [ istops ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 3*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 2*X1 + 0; 
 [ stack ] (X0,X1) = 3*X0 + 3*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 1 + 3*X0 + 3*X1 + 3*X2 + 0; 
 [ int ] (X0) = 0; 
 [ push ] (X0,X1,X2) = 3*X0 + 3*X1 + 3*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 2 + 1*X0 + 3*X1 + 3*X2 + 2*X3 + 0; 
 [ true ] () = 1 + 0; 
 [ locker2_check_availables ] (X0,X1) = 2 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 3*X1 + 0; 
 [ record_update ] (X0,X1,X2,X3) = 1 + 1*X0 + 2*X3 + 0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 0; 
 [ if ] (X0,X1,X2) = 2 + 2*X0 + 2*X1 + 2*X2 + 0; 
 [ pops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 1*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 1 + 1*X1 + 1*X3 + 0; 
 [ tuple ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 2 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 1*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 1*X0 + 0; 
 [ Marked_locker2_map_claim_lock ] (X0,X1,X2) = 3*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 3*X1 + 0; 
 [ case0 ] (X0,X1,X2) = 2 + 1*X1 + 2*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 3*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 2 + 3*X0 + 0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 1 + 1*X0 + 0; 
 [ cons ] (X0,X1) = 1 + 1*X0 + 1*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X0 + 3*X1 + 3*X2 + 3*X3 + 3*X4 + 3*X5 + 0; 
 [ member ] (X0,X1) = 0; 
 [ element ] (X0,X1) = 2 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ and ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X1 + 1*X2 + 0; 
 [ lock ] () = 1 + 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 3*X0 + 1*X1 + 2*X2 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 3 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 2*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 3 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 1 + 1*X0 + 1*X1 + 0; 
 ]} 
{
 
DP termination of:
<Marked_record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) , Marked_record_updates(
                                                                    record_update(
                                                                    Record,
                                                                    Name,
                                                                    Field,
                                                                    NewF),Name,
                                                                    Fields)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 3*X0 + 0; 
 [ record_new ] (X0) = 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 2 + 3*X0 + 3*X1 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 1*X1 + 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 3*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 2*X1 + 0; 
 [ stack ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 3 + 2*X0 + 3*X1 + 3*X2 + 0; 
 [ int ] (X0) = 0; 
 [ push ] (X0,X1,X2) = 2 + 3*X0 + 3*X1 + 2*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 2 + 1*X0 + 3*X1 + 3*X2 + 0; 
 [ true ] () = 2 + 0; 
 [ locker2_check_availables ] (X0,X1) = 2 + 3*X0 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1 + 1*X0 + 2*X3 + 0; 
 [ false ] () = 2 + 0; 
 [ locker2_release_lock ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 2*X0 + 2*X1 + 1*X3 + 0; 
 [ if ] (X0,X1,X2) = 2 + 3*X0 + 2*X1 + 2*X2 + 0; 
 [ pops ] (X0) = 3 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 3*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 3*X1 + 1*X3 + 0; 
 [ tuple ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 3 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 1 + 1*X0 + 1*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 2 + 3*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 1*X1 + 2*X2 + 0; 
 [ Marked_record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 2 + 2*X1 + 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 2*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 2 + 3*X0 + 0; 
 [ cons ] (X0,X1) = 2 + 2*X0 + 1*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X0 + 3*X1 + 1*X2 + 2*X3 + 0; 
 [ member ] (X0,X1) = 2 + 1*X1 + 0; 
 [ element ] (X0,X1) = 2 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 3 + 2*X0 + 3*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ empty ] () = 1 + 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 1*X0 + 1*X1 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 3 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 1 + 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 2 + 1*X0 + 2*X1 + 0; 
 ]} 
{
 
DP termination of:
<Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(Client,
                                                        Locks,Lock,
                                                        member(Client,
                                                         record_extract(
                                                          Lock,lock,pending)))>
<Marked_case5(Client,Locks,Lock,true) , Marked_locker2_obtainables(Locks,
                                         Client)>
<Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(Locks,
                                          Client)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ T ] () = 0; 
 [ gen_tag ] (X0) = 3*X0 + 1; 
 [ record_new ] (X0) = 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 3*X1 + 3*X0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 1*X1 + 1*X0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 2*X2 + 2*X1 + 3*X0 + 3; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0; 
 [ imp ] (X0,X1) = 2*X1 + 3*X0 + 3; 
 [ stack ] (X0,X1) = 2*X1 + 1*X0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 2*X2 + 2*X1 + 2*X0 + 1; 
 [ int ] (X0) = 2*X0; 
 [ push ] (X0,X1,X2) = 1*X1 + 3*X0; 
 [ case1 ] (X0,X1,X2,X3) = 3*X2 + 3*X1 + 1*X0; 
 [ true ] () = 2; 
 [ locker2_check_availables ] (X0,X1) = 2; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X3 + 2*X2 + 1*X0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 3*X1 + 3*X0 + 1; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 0; 
 [ if ] (X0,X1,X2) = 3*X2 + 2*X1 + 2*X0 + 2; 
 [ pops ] (X0) = 3*X0 + 2; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 3*X0; 
 [ Marked_locker2_obtainables ] (X0,X1) = 3*X1; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 2; 
 [ tuple ] (X0,X1) = 1*X1 + 1*X0; 
 [ locker2_add_pending ] (X0,X1,X2) = 1*X2 + 3*X1 + 3*X0 + 1; 
 [ s ] (X0) = 3*X0 + 2; 
 [ delete ] (X0,X1) = 1*X1; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 1*X3; 
 [ record_extract ] (X0,X1,X2) = 1*X0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 3*X0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 2*X2 + 1*X1; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X1 + 3*X0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0; 
 [ Marked_case5 ] (X0,X1,X2,X3) = 1*X3 + 3*X0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 2; 
 [ cons ] (X0,X1) = 2*X1 + 2*X0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 1*X1 + 3*X0; 
 [ member ] (X0,X1) = 0; 
 [ element ] (X0,X1) = 3*X1 + 2*X0 + 3; 
 [ locker2_adduniq ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ and ] (X0,X1) = 2*X1 + 2*X0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X2 + 1*X0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0; 
 [ calls ] (X0,X1,X2) = 0; 
 [ locker2_remove_pending ] (X0,X1) = 1*X1 + 3*X0 + 1; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3*X0 + 3; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1*X0; 
 [ append ] (X0,X1) = 1*X0; 
 [ 0 ] () = 3; 
 [ case8 ] (X0,X1,X2,X3) = 2*X1 + 2*X0; 
 removing <Marked_case5(Client,Locks,Lock,true),Marked_locker2_obtainables(
                                                 Locks,Client)>
 [ {
      
     DP termination of:
     <Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(
                                                             Client,Locks,
                                                             Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))>
<Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(Locks,
                                          Client)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_locker2_obtainables(cons(Lock,Locks),Client) , Marked_case5(
                                                             Client,Locks,
                                                             Lock,
                                                             member(Client,
                                                              record_extract(
                                                               Lock,lock,
                                                               pending)))>
<Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(Locks,
                                          Client)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ T ] () = 0; 
 [ gen_tag ] (X0) = 3*X0 + 1; 
 [ record_new ] (X0) = 2; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 3*X1 + 3*X0 + 2; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 2*X1; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3*X2 + 3*X1 + 3*X0 + 3; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0; 
 [ imp ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ stack ] (X0,X1) = 1*X1 + 1*X0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 3*X2 + 3*X1 + 3*X0 + 1; 
 [ int ] (X0) = 2*X0; 
 [ push ] (X0,X1,X2) = 2*X2 + 1*X1 + 3*X0; 
 [ case1 ] (X0,X1,X2,X3) = 3*X2 + 3*X1 + 1*X0 + 1; 
 [ true ] () = 0; 
 [ locker2_check_availables ] (X0,X1) = 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 2*X3 + 1*X0 + 1; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 0; 
 [ if ] (X0,X1,X2) = 3*X2 + 3*X1 + 3*X0 + 2; 
 [ pops ] (X0) = 3*X0 + 2; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 1*X0; 
 [ Marked_locker2_obtainables ] (X0,X1) = 3*X1 + 1*X0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 2; 
 [ tuple ] (X0,X1) = 1*X1 + 2*X0; 
 [ locker2_add_pending ] (X0,X1,X2) = 1*X2 + 3*X1 + 3*X0 + 3; 
 [ s ] (X0) = 3*X0 + 3; 
 [ delete ] (X0,X1) = 1*X1; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 3*X0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 2*X0; 
 [ case0 ] (X0,X1,X2) = 2*X2 + 1*X1 + 1; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 2*X1 + 3*X0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0 + 1; 
 [ Marked_case5 ] (X0,X1,X2,X3) = 2*X1 + 3*X0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 2; 
 [ cons ] (X0,X1) = 2*X1 + 1*X0 + 1; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X4 + 1*X1 + 3*X0; 
 [ member ] (X0,X1) = 0; 
 [ element ] (X0,X1) = 3*X1 + 1*X0 + 3; 
 [ locker2_adduniq ] (X0,X1) = 3*X1 + 2*X0 + 2; 
 [ and ] (X0,X1) = 1*X1 + 1*X0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X2 + 1*X0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0; 
 [ calls ] (X0,X1,X2) = 2*X2; 
 [ locker2_remove_pending ] (X0,X1) = 1*X1 + 3*X0 + 3; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3*X0 + 2; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 2*X0; 
 [ append ] (X0,X1) = 1*X0; 
 [ 0 ] () = 3; 
 [ case8 ] (X0,X1,X2,X3) = 1*X1 + 2*X0 + 1; 
 removing <Marked_locker2_obtainables(cons(Lock,Locks),Client),Marked_case5(
                                                                Client,
                                                                Locks,
                                                                Lock,
                                                                member(
                                                                 Client,
                                                                 record_extract(
                                                                  Lock,
                                                                  lock,
                                                                  pending)))>
 [ {
      
     DP termination of:
     <Marked_case5(Client,Locks,Lock,false) , Marked_locker2_obtainables(
                                               Locks,Client)>
 ,
 CRITERION: SG
 [  ]} 
 ]} 
 ]} 
 ]} 
{
 
DP termination of:
<Marked_locker2_check_availables(cons(Resource,Resources),Locks) , Marked_locker2_check_availables(
                                                                    Resources,
                                                                    Locks)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 3*X0 + 0; 
 [ record_new ] (X0) = 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 3 + 3*X1 + 3*X2 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 2*X1 + 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 2*X1 + 2*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 2*X1 + 0; 
 [ stack ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 1 + 2*X0 + 2*X1 + 3*X2 + 0; 
 [ int ] (X0) = 1*X0 + 0; 
 [ push ] (X0,X1,X2) = 3*X0 + 1*X1 + 2*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 3 + 1*X0 + 3*X1 + 3*X2 + 0; 
 [ true ] () = 3 + 0; 
 [ locker2_check_availables ] (X0,X1) = 3 + 1*X0 + 1*X1 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X0 + 1*X3 + 0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 2 + 0; 
 [ case6 ] (X0,X1,X2,X3) = 3 + 1*X0 + 3*X3 + 0; 
 [ if ] (X0,X1,X2) = 3 + 2*X0 + 3*X1 + 3*X2 + 0; 
 [ pops ] (X0) = 3 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 1*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 3 + 0; 
 [ tuple ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 2 + 2*X0 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 1*X0 + 2*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 2*X2 + 0; 
 [ Marked_locker2_check_availables ] (X0,X1) = 3*X0 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 1*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 1*X1 + 2*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 2 + 1*X1 + 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 3*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 3 + 0; 
 [ cons ] (X0,X1) = 2 + 2*X0 + 1*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X0 + 1*X1 + 1*X2 + 0; 
 [ member ] (X0,X1) = 1*X1 + 0; 
 [ element ] (X0,X1) = 2 + 2*X0 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 2 + 2*X0 + 2*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 1*X0 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 3 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 1*X0 + 0; 
 [ tuplenil ] (X0) = 1*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 2 + 1*X0 + 2*X1 + 0; 
 ]} 
{
 
DP termination of:
<Marked_append(cons(Head,Tail),List) , Marked_append(Tail,List)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 1*X0 + 0; 
 [ record_new ] (X0) = 2 + 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 1 + 3*X1 + 3*X2 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 2*X1 + 2*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ stack ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 2*X0 + 2*X1 + 2*X2 + 0; 
 [ int ] (X0) = 0; 
 [ push ] (X0,X1,X2) = 3*X0 + 1*X1 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 2 + 1*X0 + 3*X1 + 3*X2 + 0; 
 [ true ] () = 3 + 0; 
 [ locker2_check_availables ] (X0,X1) = 3 + 2*X0 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X0 + 1*X3 + 0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 1 + 2*X0 + 1*X3 + 0; 
 [ if ] (X0,X1,X2) = 3 + 2*X0 + 3*X1 + 3*X2 + 0; 
 [ pops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 2*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 3 + 3*X1 + 2*X2 + 0; 
 [ tuple ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 2 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 2*X0 + 1*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 1*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 2 + 1*X1 + 2*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 1*X1 + 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 2*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 2 + 3*X0 + 0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 3 + 2*X0 + 0; 
 [ cons ] (X0,X1) = 2 + 2*X0 + 2*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X0 + 1*X1 + 0; 
 [ member ] (X0,X1) = 1*X1 + 0; 
 [ element ] (X0,X1) = 2 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 2 + 3*X0 + 3*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 0; 
 [ excllock ] () = 1 + 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 0; 
 [ locker2_remove_pending ] (X0,X1) = 3 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 [ Marked_append ] (X0,X1) = 3*X0 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 2 + 2*X0 + 2*X1 + 0; 
 ]} 
{
 
DP termination of:
<Marked_subtract(List,cons(Head,Tail)) , Marked_subtract(delete(Head,List),
                                          Tail)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 1*X0 + 0; 
 [ record_new ] (X0) = 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 1 + 3*X0 + 3*X1 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 1*X0 + 2*X1 + 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 3*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ stack ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 3 + 3*X0 + 2*X1 + 3*X2 + 0; 
 [ int ] (X0) = 0; 
 [ push ] (X0,X1,X2) = 3*X0 + 1*X1 + 2*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 1 + 1*X0 + 3*X1 + 3*X2 + 0; 
 [ true ] () = 0; 
 [ locker2_check_availables ] (X0,X1) = 1 + 3*X0 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 1 + 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X0 + 1*X3 + 0; 
 [ false ] () = 2 + 0; 
 [ locker2_release_lock ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 2 + 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 2 + 2*X0 + 0; 
 [ if ] (X0,X1,X2) = 2 + 3*X0 + 3*X1 + 3*X2 + 0; 
 [ pops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 1*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 0; 
 [ tuple ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 2 + 0; 
 [ Marked_subtract ] (X0,X1) = 2*X1 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 2*X0 + 1*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 3*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 2 + 2*X0 + 1*X1 + 0; 
 [ case0 ] (X0,X1,X2) = 1 + 1*X1 + 2*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 2 + 1*X1 + 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 2*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 1 + 3*X0 + 0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 0; 
 [ cons ] (X0,X1) = 1 + 2*X0 + 2*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 2 + 3*X0 + 2*X4 + 0; 
 [ member ] (X0,X1) = 2 + 1*X1 + 0; 
 [ element ] (X0,X1) = 2 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 2 + 2*X0 + 3*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 2 + 1*X2 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 3 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 2*X0 + 2*X1 + 2*X3 + 0; 
 ]} 
{
 
DP termination of:
<Marked_eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) , Marked_eqc(CS1,CS2)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 1*X0 + 0; 
 [ record_new ] (X0) = 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 2 + 3*X1 + 3*X2 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 1*X1 + 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 3*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ stack ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 2*X0 + 2*X1 + 3*X2 + 0; 
 [ int ] (X0) = 2*X0 + 0; 
 [ push ] (X0,X1,X2) = 2 + 3*X0 + 3*X1 + 2*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 2 + 1*X0 + 3*X1 + 3*X2 + 0; 
 [ true ] () = 2 + 0; 
 [ locker2_check_availables ] (X0,X1) = 2 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X0 + 1*X3 + 0; 
 [ false ] () = 0; 
 [ Marked_eqc ] (X0,X1) = 1*X1 + 0; 
 [ locker2_release_lock ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 2 + 0; 
 [ case6 ] (X0,X1,X2,X3) = 0; 
 [ if ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 3*X2 + 0; 
 [ pops ] (X0) = 3 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 3*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 2 + 3*X1 + 2*X2 + 0; 
 [ tuple ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 3 + 3*X0 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 3*X0 + 2*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 1*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 1*X1 + 2*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 3*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 2 + 2*X0 + 0; 
 [ cons ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 2 + 3*X0 + 3*X1 + 2*X2 + 3*X4 + 0; 
 [ member ] (X0,X1) = 2*X1 + 0; 
 [ element ] (X0,X1) = 3 + 2*X0 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 2 + 3*X0 + 3*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 2 + 2*X0 + 2*X2 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 1 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 2*X0 + 2*X1 + 0; 
 ]} 
{
 
DP termination of:
<Marked_eqs(stack(E1,S1),stack(E2,S2)) , Marked_eqs(S1,S2)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 1 + 3*X0 + 0; 
 [ record_new ] (X0) = 2 + 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 3*X0 + 3*X1 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 2*X1 + 2*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ stack ] (X0,X1) = 1 + 1*X0 + 1*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ Marked_eqs ] (X0,X1) = 1*X0 + 0; 
 [ case4 ] (X0,X1,X2) = 1 + 2*X0 + 2*X1 + 3*X2 + 0; 
 [ int ] (X0) = 0; 
 [ push ] (X0,X1,X2) = 2 + 3*X0 + 3*X1 + 2*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 1*X0 + 3*X1 + 3*X2 + 0; 
 [ true ] () = 0; 
 [ locker2_check_availables ] (X0,X1) = 2*X0 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X0 + 2*X3 + 0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 1 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 2 + 0; 
 [ case6 ] (X0,X1,X2,X3) = 0; 
 [ if ] (X0,X1,X2) = 2 + 2*X0 + 3*X1 + 3*X2 + 0; 
 [ pops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 1*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 0; 
 [ tuple ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 1 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 3 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 3*X0 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ excl ] () = 0; 
 [ gen_modtageq ] (X0,X1) = 3*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 1*X1 + 2*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 1 + 3*X0 + 3*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ mcrlrecord ] () = 1 + 0; 
 [ locker2_obtainables ] (X0,X1) = 0; 
 [ cons ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X0 + 3*X1 + 1*X2 + 0; 
 [ member ] (X0,X1) = 2*X1 + 0; 
 [ element ] (X0,X1) = 3 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 3 + 3*X0 + 2*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 1*X0 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 1 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 3 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 2*X0 + 2*X1 + 0; 
 ]} 
{
 
DP termination of:
<Marked_eqt(pid(N1),pid(N2)) , Marked_eqt(N1,N2)>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ T ] () = 0; 
 [ gen_tag ] (X0) = 3*X0 + 1; 
 [ record_new ] (X0) = 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 3*X1 + 3*X0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 1*X0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 2*X2 + 3*X1 + 3*X0 + 3; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0; 
 [ imp ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ stack ] (X0,X1) = 2*X1 + 1*X0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 3*X2 + 3*X1 + 2*X0 + 1; 
 [ int ] (X0) = 0; 
 [ push ] (X0,X1,X2) = 1*X2 + 1*X1 + 3*X0; 
 [ case1 ] (X0,X1,X2,X3) = 3*X2 + 3*X1 + 1*X0; 
 [ true ] () = 0; 
 [ locker2_check_availables ] (X0,X1) = 2*X0 + 2; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X3 + 2*X2 + 1*X0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 3*X1 + 3*X0 + 1; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 2*X0; 
 [ if ] (X0,X1,X2) = 3*X2 + 2*X1 + 3*X0 + 2; 
 [ pops ] (X0) = 3*X0 + 3; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 2*X0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 2*X1 + 2; 
 [ tuple ] (X0,X1) = 1*X1 + 2*X0; 
 [ locker2_add_pending ] (X0,X1,X2) = 1*X2 + 3*X1 + 3*X0 + 1; 
 [ s ] (X0) = 3; 
 [ delete ] (X0,X1) = 1*X1; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 2*X0; 
 [ record_extract ] (X0,X1,X2) = 1*X0; 
 [ excl ] () = 0; 
 [ Marked_eqt ] (X0,X1) = 2*X1 + 2*X0; 
 [ gen_modtageq ] (X0,X1) = 3*X0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 3*X1; 
 [ case0 ] (X0,X1,X2) = 2*X2 + 1*X1; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 2*X1; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X1 + 3*X0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 2*X0 + 2; 
 [ cons ] (X0,X1) = 1*X1 + 2*X0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X4 + 3*X0; 
 [ member ] (X0,X1) = 2*X1; 
 [ element ] (X0,X1) = 3*X1 + 2; 
 [ locker2_adduniq ] (X0,X1) = 3*X1 + 3*X0 + 2; 
 [ and ] (X0,X1) = 1*X1 + 2*X0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X2 + 1*X0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 2; 
 [ calls ] (X0,X1,X2) = 3*X2; 
 [ locker2_remove_pending ] (X0,X1) = 1*X1 + 3*X0 + 1; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3*X0 + 2; 
 [ locker2_claim_lock ] (X0,X1,X2) = 1*X0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1*X0; 
 [ append ] (X0,X1) = 1*X0; 
 [ 0 ] () = 2; 
 [ case8 ] (X0,X1,X2,X3) = 2*X1 + 1*X0; 
 removing <Marked_eqt(pid(N1),pid(N2)),Marked_eqt(N1,N2)>
 [ {
      
     DP termination of:
     <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(cons(H1,T1),cons(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ T ] () = 0; 
 [ gen_tag ] (X0) = 1*X0 + 1; 
 [ record_new ] (X0) = 2; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 3*X1 + 3*X0 + 1; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 2*X1; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 2*X2 + 2*X1 + 3*X0 + 3; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0; 
 [ imp ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ stack ] (X0,X1) = 2*X1 + 1*X0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 3*X2 + 3*X1 + 3*X0 + 2; 
 [ int ] (X0) = 2*X0; 
 [ push ] (X0,X1,X2) = 3*X1 + 3*X0; 
 [ case1 ] (X0,X1,X2,X3) = 3*X2 + 3*X1 + 1*X0 + 1; 
 [ true ] () = 0; 
 [ locker2_check_availables ] (X0,X1) = 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 2*X3 + 2*X2 + 1*X0 + 1; 
 [ false ] () = 2; 
 [ locker2_release_lock ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ undefined ] () = 1; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 3*X0 + 2; 
 [ if ] (X0,X1,X2) = 3*X2 + 3*X1 + 3*X0 + 3; 
 [ pops ] (X0) = 3*X0 + 3; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 3*X0 + 1; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 0; 
 [ tuple ] (X0,X1) = 1*X1 + 1*X0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3*X2 + 3*X1 + 3*X0 + 3; 
 [ s ] (X0) = 2*X0 + 2; 
 [ delete ] (X0,X1) = 1*X1; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 3*X0 + 2; 
 [ record_extract ] (X0,X1,X2) = 1*X0; 
 [ excl ] () = 0; 
 [ Marked_eqt ] (X0,X1) = 1*X1; 
 [ gen_modtageq ] (X0,X1) = 3*X0 + 2; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 2*X2 + 1*X1 + 1; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 2*X1 + 2; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X1 + 3*X0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0 + 1; 
 [ mcrlrecord ] () = 1; 
 [ locker2_obtainables ] (X0,X1) = 0; 
 [ cons ] (X0,X1) = 2*X1 + 2*X0 + 1; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X1 + 3*X0; 
 [ member ] (X0,X1) = 2*X1 + 2; 
 [ element ] (X0,X1) = 3*X1 + 2*X0 + 2; 
 [ locker2_adduniq ] (X0,X1) = 2*X1 + 3*X0 + 3; 
 [ and ] (X0,X1) = 2*X1 + 2*X0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X2 + 1*X0; 
 [ lock ] () = 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0; 
 [ calls ] (X0,X1,X2) = 0; 
 [ locker2_remove_pending ] (X0,X1) = 1*X1 + 3*X0 + 3; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 1; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3*X0 + 2; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1*X0; 
 [ append ] (X0,X1) = 1*X0; 
 [ 0 ] () = 2; 
 [ case8 ] (X0,X1,X2,X3) = 1*X3 + 2*X1 + 2*X0; 
 removing <Marked_eqt(cons(H1,T1),cons(H2,T2)),Marked_eqt(H1,H2)><Marked_eqt(
                                                                   cons(
                                                                    H1,
                                                                    T1),
                                                                   cons(H2,T2)),
Marked_eqt(T1,T2)>
 [ {
      
     DP termination of:
     <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(H1,H2)>
<Marked_eqt(tuple(H1,T1),tuple(H2,T2)) , Marked_eqt(T1,T2)>
<Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
 ,
 CRITERION: CG using polynomial interpretation = 
 [ T ] () = 0; 
 [ gen_tag ] (X0) = 3*X0 + 3; 
 [ record_new ] (X0) = 3*X0 + 3; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 3*X1 + 3*X0 + 2; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 1*X1 + 1*X0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3*X2 + 3*X1 + 3*X0 + 3; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0; 
 [ imp ] (X0,X1) = 2*X1 + 3*X0 + 3; 
 [ stack ] (X0,X1) = 2*X1 + 2*X0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 2*X2 + 3*X1 + 3*X0 + 1; 
 [ int ] (X0) = 0; 
 [ push ] (X0,X1,X2) = 2*X2 + 3*X1 + 3*X0; 
 [ case1 ] (X0,X1,X2,X3) = 3*X2 + 3*X1 + 1*X0 + 2; 
 [ true ] () = 2; 
 [ locker2_check_availables ] (X0,X1) = 2*X0 + 2; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X3 + 2*X2 + 1*X0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 3*X1 + 3*X0 + 3; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 1; 
 [ subtract ] (X0,X1) = 1*X0 + 1; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 3*X3 + 2*X0 + 2; 
 [ if ] (X0,X1,X2) = 2*X2 + 2*X1 + 2*X0 + 3; 
 [ pops ] (X0) = 3*X0 + 3; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 3*X0 + 1; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 1*X3 + 2*X1 + 2; 
 [ tuple ] (X0,X1) = 1*X1 + 2*X0 + 1; 
 [ locker2_add_pending ] (X0,X1,X2) = 1*X2 + 3*X1 + 3*X0 + 3; 
 [ s ] (X0) = 2; 
 [ delete ] (X0,X1) = 1*X1; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 2*X3 + 2*X0; 
 [ record_extract ] (X0,X1,X2) = 1*X0; 
 [ excl ] () = 0; 
 [ Marked_eqt ] (X0,X1) = 1*X1; 
 [ gen_modtageq ] (X0,X1) = 3*X0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 2*X2 + 1*X1 + 2; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 2*X1; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 2*X1 + 3*X0; 
 [ locker2_promote_pending ] (X0,X1) = 3*X0 + 2; 
 [ mcrlrecord ] () = 0; 
 [ locker2_obtainables ] (X0,X1) = 2*X0 + 2; 
 [ cons ] (X0,X1) = 1*X1 + 1*X0 + 1; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 3*X1 + 3*X0 + 2; 
 [ member ] (X0,X1) = 2*X1; 
 [ element ] (X0,X1) = 3*X1 + 2; 
 [ locker2_adduniq ] (X0,X1) = 3*X1 + 2*X0 + 3; 
 [ and ] (X0,X1) = 2*X1 + 2*X0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X2 + 1*X0; 
 [ lock ] () = 1; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0; 
 [ calls ] (X0,X1,X2) = 1; 
 [ locker2_remove_pending ] (X0,X1) = 1*X1 + 3*X0 + 3; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 3*X0 + 2; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 2; 
 [ tuplenil ] (X0) = 1*X0; 
 [ append ] (X0,X1) = 2*X0; 
 [ 0 ] () = 3; 
 [ case8 ] (X0,X1,X2,X3) = 1*X1 + 1*X0 + 1; 
 removing <Marked_eqt(tuple(H1,T1),tuple(H2,T2)),Marked_eqt(H1,H2)><Marked_eqt(
                                                                    tuple(
                                                                    H1,
                                                                    T1),
                                                                    tuple(
                                                                    H2,
                                                                    T2)),
Marked_eqt(T1,T2)>
 [ {
      
     DP termination of:
     <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
 ,
 CRITERION: SG
 [ {
      
     DP termination of:
     <Marked_eqt(tuplenil(H1),tuplenil(H2)) , Marked_eqt(H1,H2)>
 ,
 CRITERION: ORD
 [ 
     Solution found:
     polynomial interpretation = 
      [ T ] () = 0; 
 [ gen_tag ] (X0) = 3 + 3*X0 + 0; 
 [ record_new ] (X0) = 2 + 3*X0 + 0; 
 [ a ] () = 0; 
 [ case2 ] (X0,X1,X2) = 2 + 3*X0 + 3*X1 + 0; 
 [ eqt ] (X0,X1) = 0; 
 [ istops ] (X0,X1) = 1*X0 + 2*X1 + 0; 
 [ locker2_map_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 2*X1 + 2*X2 + 0; 
 [ release ] () = 0; 
 [ locker2_obtainable ] (X0,X1) = 3*X0 + 0; 
 [ imp ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ stack ] (X0,X1) = 1*X0 + 1*X1 + 0; 
 [ locker2_map_promote_pending ] (X0,X1) = 3*X0 + 0; 
 [ locker ] () = 0; 
 [ case4 ] (X0,X1,X2) = 1 + 2*X0 + 3*X1 + 2*X2 + 0; 
 [ int ] (X0) = 0; 
 [ push ] (X0,X1,X2) = 1 + 3*X0 + 3*X1 + 2*X2 + 0; 
 [ case1 ] (X0,X1,X2,X3) = 2 + 1*X0 + 3*X2 + 3*X3 + 0; 
 [ true ] () = 2 + 0; 
 [ locker2_check_availables ] (X0,X1) = 2 + 1*X0 + 0; 
 [ F ] () = 0; 
 [ eqs ] (X0,X1) = 0; 
 [ record_update ] (X0,X1,X2,X3) = 1*X0 + 2*X3 + 0; 
 [ false ] () = 0; 
 [ locker2_release_lock ] (X0,X1) = 3 + 3*X0 + 3*X1 + 0; 
 [ undefined ] () = 0; 
 [ nocalls ] () = 0; 
 [ subtract ] (X0,X1) = 1*X0 + 0; 
 [ resource ] () = 0; 
 [ case6 ] (X0,X1,X2,X3) = 0; 
 [ if ] (X0,X1,X2) = 2 + 2*X0 + 3*X1 + 3*X2 + 0; 
 [ pops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_map_claim_lock ] (X0,X1,X2) = 2*X0 + 0; 
 [ ok ] () = 0; 
 [ case5 ] (X0,X1,X2,X3) = 2 + 2*X1 + 0; 
 [ tuple ] (X0,X1) = 2*X0 + 1*X1 + 0; 
 [ locker2_add_pending ] (X0,X1,X2) = 3 + 3*X0 + 3*X1 + 1*X2 + 0; 
 [ s ] (X0) = 2 + 0; 
 [ delete ] (X0,X1) = 1*X1 + 0; 
 [ or ] (X0,X1) = 0; 
 [ case9 ] (X0,X1,X2,X3) = 1*X0 + 1*X1 + 2*X3 + 0; 
 [ record_extract ] (X0,X1,X2) = 1*X0 + 0; 
 [ excl ] () = 0; 
 [ Marked_eqt ] (X0,X1) = 1*X0 + 0; 
 [ gen_modtageq ] (X0,X1) = 3*X0 + 0; 
 [ nil ] () = 0; 
 [ eqc ] (X0,X1) = 0; 
 [ case0 ] (X0,X1,X2) = 2 + 1*X1 + 2*X2 + 0; 
 [ request ] () = 0; 
 [ locker2_check_available ] (X0,X1) = 0; 
 [ not ] (X0) = 0; 
 [ pushs ] (X0,X1) = 3*X0 + 2*X1 + 0; 
 [ locker2_promote_pending ] (X0,X1) = 2 + 3*X0 + 0; 
 [ mcrlrecord ] () = 1 + 0; 
 [ locker2_obtainables ] (X0,X1) = 2 + 2*X0 + 0; 
 [ cons ] (X0,X1) = 2 + 1*X0 + 1*X1 + 0; 
 [ push1 ] (X0,X1,X2,X3,X4,X5) = 1 + 3*X0 + 2*X1 + 2*X2 + 0; 
 [ member ] (X0,X1) = 1*X1 + 0; 
 [ element ] (X0,X1) = 2 + 3*X1 + 0; 
 [ locker2_adduniq ] (X0,X1) = 3 + 2*X0 + 3*X1 + 0; 
 [ and ] (X0,X1) = 2*X0 + 2*X1 + 0; 
 [ empty ] () = 0; 
 [ record_updates ] (X0,X1,X2) = 1*X0 + 1*X2 + 0; 
 [ lock ] () = 2 + 0; 
 [ excllock ] () = 0; 
 [ pid ] (X0) = 3*X0 + 0; 
 [ calls ] (X0,X1,X2) = 2*X0 + 0; 
 [ locker2_remove_pending ] (X0,X1) = 3 + 3*X0 + 1*X1 + 0; 
 [ tag ] () = 0; 
 [ equal ] (X0,X1) = 0; 
 [ eq ] (X0,X1) = 0; 
 [ tops ] (X0) = 2 + 3*X0 + 0; 
 [ locker2_claim_lock ] (X0,X1,X2) = 0; 
 [ pending ] () = 0; 
 [ andt ] (X0,X1) = 0; 
 [ tuplenil ] (X0) = 1 + 2*X0 + 0; 
 [ append ] (X0,X1) = 1*X0 + 0; 
 [ 0 ] () = 2 + 0; 
 [ case8 ] (X0,X1,X2,X3) = 2 + 1*X0 + 1*X1 + 0; 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 
 ]} 

Cime worked for 22.842755 seconds (real time)
Cime Exit Status: 0