MAYBE Time: 0.068927 TRS: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } DP: DP: { eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2)), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2)), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), element#(int s s N1, tuple(T1, T2)) -> element#(int s N1, T2), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_update#(Record, Name, Field, NewF), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields), locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_map_promote_pending#(Locks, Pending), locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_promote_pending#(Lock, Pending), locker2_promote_pending#(Lock, Client) -> record_extract#(Lock, lock(), pending()), locker2_promote_pending#(Lock, Client) -> case0#(Client, Lock, record_extract(Lock, lock(), pending())), locker2_map_claim_lock#(cons(Lock, Locks), Resources, Client) -> locker2_map_claim_lock#(Locks, Resources, Client), case0#(Client, Lock, cons(Client, Pendings)) -> record_updates#(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), subtract#(List, cons(Head, Tail)) -> subtract#(delete(Head, List), Tail), subtract#(List, cons(Head, Tail)) -> delete#(Head, List), locker2_remove_pending#(Lock, Client) -> record_extract#(Lock, lock(), pending()), locker2_remove_pending#(Lock, Client) -> record_updates#(Lock, lock(), cons(tuple(pending(), tuplenil subtract(record_extract(Lock, lock(), pending()), cons(Client, nil()))), nil())), locker2_remove_pending#(Lock, Client) -> subtract#(record_extract(Lock, lock(), pending()), cons(Client, nil())), case1#(Client, Resources, Lock, true()) -> record_extract#(Lock, lock(), pending()), case1#(Client, Resources, Lock, true()) -> record_updates#(Lock, lock(), cons(tuple(pending(), tuplenil append(record_extract(Lock, lock(), pending()), cons(Client, nil()))), nil())), case1#(Client, Resources, Lock, true()) -> append#(record_extract(Lock, lock(), pending()), cons(Client, nil())), member#(E, cons(Head, Tail)) -> case9#(Tail, Head, E, equal(E, Head)), locker2_add_pending#(Lock, Resources, Client) -> record_extract#(Lock, lock(), resource()), locker2_add_pending#(Lock, Resources, Client) -> case1#(Client, Resources, Lock, member(record_extract(Lock, lock(), resource()), Resources)), locker2_add_pending#(Lock, Resources, Client) -> member#(record_extract(Lock, lock(), resource()), Resources), append#(cons(Head, Tail), List) -> append#(Tail, List), case2#(Client, Lock, true()) -> record_updates#(Lock, lock(), cons(tuple(excllock(), excl()), nil())), locker2_release_lock#(Lock, Client) -> record_extract#(Lock, lock(), excl()), locker2_release_lock#(Lock, Client) -> case2#(Client, Lock, gen_modtageq(Client, record_extract(Lock, lock(), excl()))), locker2_release_lock#(Lock, Client) -> gen_modtageq#(Client, record_extract(Lock, lock(), excl())), locker2_obtainables#(cons(Lock, Locks), Client) -> record_extract#(Lock, lock(), pending()), locker2_obtainables#(cons(Lock, Locks), Client) -> member#(Client, record_extract(Lock, lock(), pending())), 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()) -> locker2_obtainables#(Locks, Client), locker2_check_available#(Resource, cons(Lock, Locks)) -> record_extract#(Lock, lock(), resource()), 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()) -> record_extract#(Lock, lock(), excl()), case6#(Locks, Lock, Resource, true()) -> record_extract#(Lock, lock(), pending()), locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_available#(Resource, Locks), locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_availables#(Resources, Locks), delete#(E, cons(Head, Tail)) -> case8#(Tail, Head, E, equal(E, Head)), case8#(Tail, Head, E, false()) -> delete#(E, Tail), case9#(Tail, Head, E, false()) -> member#(E, Tail), eqs#(stack(E1, S1), stack(E2, S2)) -> and#(eqt(E1, E2), eqs(S1, S2)), eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqs#(stack(E1, S1), stack(E2, S2)) -> eqs#(S1, S2), istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> and#(eqt(E1, E2), and(eqs(S1, S2), eqc(CS1, CS2))), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> and#(eqs(S1, S2), eqc(CS1, CS2)), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqs#(S1, S2), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2), push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), push#(E1, E2, calls(E3, S1, CS1)) -> push1#(E1, E2, E3, S1, CS1, eqt(E1, E3)), push1#(E1, E2, E3, S1, CS1, T()) -> pushs#(E2, S1)} TRS: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } EDG: { (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (member#(E, cons(Head, Tail)) -> case9#(Tail, Head, E, equal(E, Head)), case9#(Tail, Head, E, false()) -> member#(E, Tail)) (locker2_obtainables#(cons(Lock, Locks), Client) -> case5#(Client, Locks, Lock, member(Client, record_extract(Lock, lock(), pending()))), case5#(Client, Locks, Lock, true()) -> locker2_obtainables#(Locks, Client)) (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)) (delete#(E, cons(Head, Tail)) -> case8#(Tail, Head, E, equal(E, Head)), case8#(Tail, Head, E, false()) -> delete#(E, Tail)) (locker2_obtainables#(cons(Lock, Locks), Client) -> member#(Client, record_extract(Lock, lock(), pending())), member#(E, cons(Head, Tail)) -> case9#(Tail, Head, E, equal(E, Head))) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields)) (record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_update#(Record, Name, Field, NewF)) (locker2_remove_pending#(Lock, Client) -> record_updates#(Lock, lock(), cons(tuple(pending(), tuplenil subtract(record_extract(Lock, lock(), pending()), cons(Client, nil()))), nil())), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields)) (locker2_remove_pending#(Lock, Client) -> record_updates#(Lock, lock(), cons(tuple(pending(), tuplenil subtract(record_extract(Lock, lock(), pending()), cons(Client, nil()))), nil())), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_update#(Record, Name, Field, NewF)) (case2#(Client, Lock, true()) -> record_updates#(Lock, lock(), cons(tuple(excllock(), excl()), nil())), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields)) (case2#(Client, Lock, true()) -> record_updates#(Lock, lock(), cons(tuple(excllock(), excl()), nil())), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_update#(Record, Name, Field, NewF)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqs#(S1, S2), eqs#(stack(E1, S1), stack(E2, S2)) -> eqs#(S1, S2)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqs#(S1, S2), eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2)) (eqs#(stack(E1, S1), stack(E2, S2)) -> eqs#(S1, S2), eqs#(stack(E1, S1), stack(E2, S2)) -> and#(eqt(E1, E2), eqs(S1, S2))) (locker2_map_claim_lock#(cons(Lock, Locks), Resources, Client) -> locker2_map_claim_lock#(Locks, Resources, Client), locker2_map_claim_lock#(cons(Lock, Locks), Resources, Client) -> locker2_map_claim_lock#(Locks, Resources, Client)) (locker2_add_pending#(Lock, Resources, Client) -> member#(record_extract(Lock, lock(), resource()), Resources), member#(E, cons(Head, Tail)) -> case9#(Tail, Head, E, equal(E, Head))) (locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_promote_pending#(Lock, Pending), locker2_promote_pending#(Lock, Client) -> case0#(Client, Lock, record_extract(Lock, lock(), pending()))) (locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_promote_pending#(Lock, Pending), locker2_promote_pending#(Lock, Client) -> record_extract#(Lock, lock(), pending())) (case6#(Locks, Lock, Resource, false()) -> locker2_check_available#(Resource, Locks), 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), locker2_check_available#(Resource, cons(Lock, Locks)) -> record_extract#(Lock, lock(), resource())) (locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_availables#(Resources, Locks), locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_availables#(Resources, Locks)) (locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_availables#(Resources, Locks), locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_available#(Resource, Locks)) (case5#(Client, Locks, Lock, false()) -> locker2_obtainables#(Locks, Client), 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), locker2_obtainables#(cons(Lock, Locks), Client) -> member#(Client, record_extract(Lock, lock(), pending()))) (case5#(Client, Locks, Lock, false()) -> locker2_obtainables#(Locks, Client), locker2_obtainables#(cons(Lock, Locks), Client) -> record_extract#(Lock, lock(), pending())) (locker2_remove_pending#(Lock, Client) -> subtract#(record_extract(Lock, lock(), pending()), cons(Client, nil())), subtract#(List, cons(Head, Tail)) -> delete#(Head, List)) (locker2_remove_pending#(Lock, Client) -> subtract#(record_extract(Lock, lock(), pending()), cons(Client, nil())), subtract#(List, cons(Head, Tail)) -> subtract#(delete(Head, List), Tail)) (subtract#(List, cons(Head, Tail)) -> subtract#(delete(Head, List), Tail), subtract#(List, cons(Head, Tail)) -> delete#(Head, List)) (subtract#(List, cons(Head, Tail)) -> subtract#(delete(Head, List), Tail), subtract#(List, cons(Head, Tail)) -> subtract#(delete(Head, List), Tail)) (element#(int s s N1, tuple(T1, T2)) -> element#(int s N1, T2), element#(int s s N1, tuple(T1, T2)) -> element#(int s N1, T2)) (append#(cons(Head, Tail), List) -> append#(Tail, List), append#(cons(Head, Tail), List) -> append#(Tail, List)) (case8#(Tail, Head, E, false()) -> delete#(E, Tail), delete#(E, cons(Head, Tail)) -> case8#(Tail, Head, E, equal(E, Head))) (case9#(Tail, Head, E, false()) -> member#(E, Tail), member#(E, cons(Head, Tail)) -> case9#(Tail, Head, E, equal(E, Head))) (eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (subtract#(List, cons(Head, Tail)) -> delete#(Head, List), delete#(E, cons(Head, Tail)) -> case8#(Tail, Head, E, equal(E, Head))) (case1#(Client, Resources, Lock, true()) -> append#(record_extract(Lock, lock(), pending()), cons(Client, nil())), append#(cons(Head, Tail), List) -> append#(Tail, List)) (case5#(Client, Locks, Lock, true()) -> locker2_obtainables#(Locks, Client), locker2_obtainables#(cons(Lock, Locks), Client) -> record_extract#(Lock, lock(), pending())) (case5#(Client, Locks, Lock, true()) -> locker2_obtainables#(Locks, Client), locker2_obtainables#(cons(Lock, Locks), Client) -> member#(Client, record_extract(Lock, lock(), pending()))) (case5#(Client, Locks, Lock, true()) -> locker2_obtainables#(Locks, Client), locker2_obtainables#(cons(Lock, Locks), Client) -> case5#(Client, Locks, Lock, member(Client, record_extract(Lock, lock(), pending())))) (locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_available#(Resource, Locks), locker2_check_available#(Resource, cons(Lock, Locks)) -> record_extract#(Lock, lock(), resource())) (locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_available#(Resource, Locks), locker2_check_available#(Resource, cons(Lock, Locks)) -> case6#(Locks, Lock, Resource, equal(Resource, record_extract(Lock, lock(), resource())))) (push#(E1, E2, calls(E3, S1, CS1)) -> push1#(E1, E2, E3, S1, CS1, eqt(E1, E3)), push1#(E1, E2, E3, S1, CS1, T()) -> pushs#(E2, S1)) (locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_map_promote_pending#(Locks, Pending), locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_map_promote_pending#(Locks, Pending)) (locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_map_promote_pending#(Locks, Pending), locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_promote_pending#(Lock, Pending)) (push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (push#(E1, E2, calls(E3, S1, CS1)) -> eqt#(E1, E3), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> and#(eqt(E1, E2), and(eqs(S1, S2), eqc(CS1, CS2)))) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> and#(eqs(S1, S2), eqc(CS1, CS2))) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqt#(E1, E2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqs#(S1, S2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2), eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqs#(S1, S2), eqs#(stack(E1, S1), stack(E2, S2)) -> and#(eqt(E1, E2), eqs(S1, S2))) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqs#(S1, S2), eqs#(stack(E1, S1), stack(E2, S2)) -> eqt#(E1, E2)) (eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqs#(S1, S2), eqs#(stack(E1, S1), stack(E2, S2)) -> eqs#(S1, S2)) (locker2_promote_pending#(Lock, Client) -> case0#(Client, Lock, record_extract(Lock, lock(), pending())), case0#(Client, Lock, cons(Client, Pendings)) -> record_updates#(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil())))) (istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (istops#(E1, stack(E2, S1)) -> eqt#(E1, E2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (locker2_release_lock#(Lock, Client) -> case2#(Client, Lock, gen_modtageq(Client, record_extract(Lock, lock(), excl()))), case2#(Client, Lock, true()) -> record_updates#(Lock, lock(), cons(tuple(excllock(), excl()), nil()))) (case1#(Client, Resources, Lock, true()) -> record_updates#(Lock, lock(), cons(tuple(pending(), tuplenil append(record_extract(Lock, lock(), pending()), cons(Client, nil()))), nil())), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_update#(Record, Name, Field, NewF)) (case1#(Client, Resources, Lock, true()) -> record_updates#(Lock, lock(), cons(tuple(pending(), tuplenil append(record_extract(Lock, lock(), pending()), cons(Client, nil()))), nil())), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields)) (case0#(Client, Lock, cons(Client, Pendings)) -> record_updates#(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_update#(Record, Name, Field, NewF)) (case0#(Client, Lock, cons(Client, Pendings)) -> record_updates#(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (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)) (locker2_check_available#(Resource, cons(Lock, Locks)) -> case6#(Locks, Lock, Resource, equal(Resource, record_extract(Lock, lock(), resource()))), case6#(Locks, Lock, Resource, true()) -> record_extract#(Lock, lock(), excl())) (locker2_check_available#(Resource, cons(Lock, Locks)) -> case6#(Locks, Lock, Resource, equal(Resource, record_extract(Lock, lock(), resource()))), case6#(Locks, Lock, Resource, true()) -> record_extract#(Lock, lock(), pending())) (locker2_add_pending#(Lock, Resources, Client) -> case1#(Client, Resources, Lock, member(record_extract(Lock, lock(), resource()), Resources)), case1#(Client, Resources, Lock, true()) -> record_extract#(Lock, lock(), pending())) (locker2_add_pending#(Lock, Resources, Client) -> case1#(Client, Resources, Lock, member(record_extract(Lock, lock(), resource()), Resources)), case1#(Client, Resources, Lock, true()) -> record_updates#(Lock, lock(), cons(tuple(pending(), tuplenil append(record_extract(Lock, lock(), pending()), cons(Client, nil()))), nil()))) (locker2_add_pending#(Lock, Resources, Client) -> case1#(Client, Resources, Lock, member(record_extract(Lock, lock(), resource()), Resources)), case1#(Client, Resources, Lock, true()) -> append#(record_extract(Lock, lock(), pending()), cons(Client, nil()))) (eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(pid N1, pid N2) -> eqt#(N1, N2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> and#(eqt(H1, H2), eqt(T1, T2))) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2)) (eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)) } STATUS: arrows: 0.961569 SCCS (14): Scc: {element#(int s s N1, tuple(T1, T2)) -> element#(int s N1, T2)} Scc: {subtract#(List, cons(Head, Tail)) -> subtract#(delete(Head, List), Tail)} Scc: {locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_availables#(Resources, Locks)} Scc: {locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_map_promote_pending#(Locks, Pending)} Scc: {locker2_map_claim_lock#(cons(Lock, Locks), Resources, Client) -> locker2_map_claim_lock#(Locks, Resources, Client)} Scc: {eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2)} Scc: {eqs#(stack(E1, S1), stack(E2, S2)) -> eqs#(S1, S2)} Scc: { delete#(E, cons(Head, Tail)) -> case8#(Tail, Head, E, equal(E, Head)), case8#(Tail, Head, E, false()) -> delete#(E, Tail)} Scc: {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)} Scc: {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()) -> locker2_obtainables#(Locks, Client)} Scc: {append#(cons(Head, Tail), List) -> append#(Tail, List)} Scc: {record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields)} Scc: { member#(E, cons(Head, Tail)) -> case9#(Tail, Head, E, equal(E, Head)), case9#(Tail, Head, E, false()) -> member#(E, Tail)} Scc: { eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)} SCC (1): Strict: {element#(int s s N1, tuple(T1, T2)) -> element#(int s N1, T2)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (1): Strict: {subtract#(List, cons(Head, Tail)) -> subtract#(delete(Head, List), Tail)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (1): Strict: {locker2_check_availables#(cons(Resource, Resources), Locks) -> locker2_check_availables#(Resources, Locks)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (1): Strict: {locker2_map_promote_pending#(cons(Lock, Locks), Pending) -> locker2_map_promote_pending#(Locks, Pending)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (1): Strict: {locker2_map_claim_lock#(cons(Lock, Locks), Resources, Client) -> locker2_map_claim_lock#(Locks, Resources, Client)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (1): Strict: {eqc#(calls(E1, S1, CS1), calls(E2, S2, CS2)) -> eqc#(CS1, CS2)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (1): Strict: {eqs#(stack(E1, S1), stack(E2, S2)) -> eqs#(S1, S2)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (2): Strict: { delete#(E, cons(Head, Tail)) -> case8#(Tail, Head, E, equal(E, Head)), case8#(Tail, Head, E, false()) -> delete#(E, Tail)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (2): Strict: {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)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (3): Strict: {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()) -> locker2_obtainables#(Locks, Client)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (1): Strict: {append#(cons(Head, Tail), List) -> append#(Tail, List)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (1): Strict: {record_updates#(Record, Name, cons(tuple(Field, tuplenil NewF), Fields)) -> record_updates#(record_update(Record, Name, Field, NewF), Name, Fields)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (2): Strict: { member#(E, cons(Head, Tail)) -> case9#(Tail, Head, E, equal(E, Head)), case9#(Tail, Head, E, false()) -> member#(E, Tail)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open SCC (6): Strict: { eqt#(pid N1, pid N2) -> eqt#(N1, N2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(H1, H2), eqt#(cons(H1, T1), cons(H2, T2)) -> eqt#(T1, T2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(H1, H2), eqt#(tuple(H1, T1), tuple(H2, T2)) -> eqt#(T1, T2), eqt#(tuplenil H1, tuplenil H2) -> eqt#(H1, H2)} Weak: { or(T(), T()) -> T(), or(T(), F()) -> T(), or(F(), T()) -> T(), or(F(), F()) -> F(), and(B, T()) -> B, and(B, F()) -> F(), and(T(), B) -> B, and(F(), B) -> 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, MCRLFree0) -> Lock, case0(Client, Lock, cons(Client, Pendings)) -> record_updates(Lock, lock(), cons(tuple(excl(), tuplenil Client), cons(tuple(pending(), tuplenil Pendings), nil()))), 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) } Open