state_packing

avl_top_val2(node(Val,_,_,L,R),Val) :- L \= empty, R\=empty.

compress_bv([P|T],Val,Len,Rest) :- get_bool_bv(P,Acc), compress_bv2(T,Acc,Val,Len,Rest).

compress_bv2([P|T],Acc,Val,Len,Rest) :- get_bool_bv(P,BoolVal),!,
    Acc2 is Acc + BoolVal*2, % BoolVal+(Acc << 1),
    compress_bv3(T,Acc2,Val,2,Len,Rest).

compress_bv3([P|T],Acc,Val,AccLen,Len,Rest) :- %get_bool_bv(P,BoolVal),!,
    (P=pred_true -> Acc2 is Acc + (1 << AccLen) ; P=pred_false -> Acc2 = Acc), !,
    %Acc2 is Acc + BoolVal*(2^AccLen),
    AccLen2 is AccLen+1, compress_bv3(T,Acc2,Val,AccLen2,Len,Rest).

compress_bv3(Rest,Acc,Acc,AccLen,AccLen,Rest). % we have a non BOOL value

compress_list([A,B,C|T],l3(A,B,C,CT)) :- !, compress_list(T,CT).

compress_list(T,T).

fd_type_can_be_packed_to_bv(Type) :-
    b_get_fd_type_bounds(Type,1,UpBound), integer(UpBound),
    max_tagged_pow2(MaxBound),
    UpBound < MaxBound.

gen_fd_atom(Nr,T,NewAtom) :-
    atom_codes(T,TC),
    number_codes(Nr,NrC),
    append(TC,NrC,TNrC),
    atom_codes(NewAtom,[36,102,100,95|TNrC]). % generates '$fd_TNr atom

gen_packed_bind_list([],[],[]).

gen_packed_bind_list([Val|T],[Var|VT],R) :- R=[bind(Var,Val)|UPT],
    gen_packed_bind_list(T,VT,UPT).

get_bind_skeleton(Category,X) :-
    (bind_skeleton(Category,X) -> true
    ; add_internal_error('No bind skeleton stored for: ',get_bind_skeleton(Category,X)),fail).

get_bool_bv(pred_true,1).

get_bool_bv(pred_false,0).

get_packed_b_state_with_uncompressed_lists(csp_and_b(_,B),Res) :- !,
    get_packed_b_state_with_uncompressed_lists(B,Res).

get_packed_b_state_with_uncompressed_lists(const_and_vars(ID,List),const_and_vars(ID,Res)) :-
    get_packed_b_state_with_uncompressed_lists(List,Res).

get_packed_b_state_with_uncompressed_lists('$cst_vars'(ID,CS),const_and_vars(ID,Res)) :-
    uncompress_list(CS,List),
    get_bind_skeleton(const_and_vars,Skel),
    gen_packed_bind_list(List,Skel,Res).

get_packed_b_state_with_uncompressed_lists('$bind_lst'(Val,CT),[bind(Var1,Val)|Res]) :- uncompress_list(CT,List),
    get_bind_skeleton(list,[Var1|Skel]),
    gen_packed_bind_list(List,Skel,Res).

incr_pack_bind_list([],_,Unchanged,[]) :-
    (Unchanged=[] -> true ; add_internal_error('Did not encounter these unchanged vars:',Unchanged)).

incr_pack_bind_list([bind(V,Val)|T],[bind(V,PrevV)|PrevT],Unchanged,[PackedValue|PT]) :-
    incremental_pack_value(Val,V,PrevV,Unchanged,PackedValue,U2),
    incr_pack_bind_list(T,PrevT,U2,PT).

incremental_pack_state(const_and_vars(ID,T),const_and_vars(ID,PrevCT),Unchanged,'$cst_vars'(ID,PCT)) :- !,
    uncompress_list(PrevCT,PrevT),
    incr_pack_bind_list(T,PrevT,Unchanged,PT),
    compress_list(PT,PCT).

incremental_pack_state([bind(V,Val)|T],[bind(V,PrevV)|PrevCT],Unchanged,'$bind_lst'(PV,PCT)) :- !,
    uncompress_list(PrevCT,PrevT),
    incremental_pack_value(Val,V,PrevV,Unchanged,PV,U2),
    incr_pack_bind_list(T,PrevT,U2,PT),
    compress_list(PT,PCT).

incremental_pack_state(State,Prev,UC,PackedState) :-
    tools_printing:print_term_summary(non_incremental_pack_state(State,Prev,UC,PackedState)),nl,
    pack_state(State,PackedState).

incremental_pack_value(_,Var,PrevPackVal,[Var|U2],PackedValue,U2) :- % copy previously packed value
    !, PackedValue=PrevPackVal.

incremental_pack_value(Val,_Var,_Prev,Unchanged,PackedValue,Unchanged) :-
    pack_value(Val,PackedValue).

l_pack_value([],[]).

l_pack_value([H|T],[PH|PT]) :- pack_value(H,PH), l_pack_value(T,PT).

l_unpack_value([],[]).

l_unpack_value([H|T],[PH-true|PT]) :- unpack_value(H,PH), l_unpack_value(T,PT).

pack_avl(empty, empty).

pack_avl(node(Val,_,0,empty,empty), R) :- !,
    R= packed_leaf(PackedVal),
    pack_value(Val,PackedVal).

pack_avl(node(Val,true,B,L0,R0), packed_node(PackedVal,B,L1,R1)) :-
    pack_value(Val,PackedVal),
    pack_avl(L0, L1), % TODO: we could store L, R separately
    pack_avl(R0, R1).

pack_avl_set(Avl,R) :- preference(use_state_packing,Pref), pack_avl_set_aux(Avl,Pref,R).

pack_avl_set_aux(A,full,R) :-
    avl_top_val2(A,(_,Bool)), (Bool=pred_false ; Bool=pred_true), % we have a relation/function to BOOL
    !,
    pack_relation(A,DomSkel,RangeVals),
    compress_bv(RangeVals,BVVal,BVLen,[]), !, % Store function/relation skeleton separately and compress bv
    %print(rel_packed(Val,Len,Rest)),nl,
    R='$stored_avl_rel_bv_packed'(ID1,BVVal),
    store_value((BVLen,DomSkel),ID1).

pack_avl_set_aux(A,full,R) :- %R\==[],
    avl_domain(A,AD),
    (pack_fd_set(AD,Type,PackedInteger)
    -> !,
    R = '$avl_bv'(PackedInteger,Type) % avl bit vector
    ; AD = [_,_|_], % at least two elements
    !,
    l_pack_value(AD,ADL),
    R='$stored_avl_exp'(ID),
    store_value(ADL,ID)
).

pack_avl_set_aux(A,_,R) :- A = node(fd(_,Type),_,_,_,_),
    % maybe we want to disable this for Pref=false ? TODO: benchmark (for nota.mch pack_fd_set seems slightly better)
    fd_type_can_be_packed_to_bv(Type),
    avl_domain(A,AD),
    pack_fd_set(AD,Type,PackedInteger),!,
    R = '$avl_bv'(PackedInteger,Type).

pack_avl_set_aux(A,Pref,R) :- !,
    %avl_height(A,Height), format('Packing avl with height ~w (pref: ~w)~n',[Height,Pref]),
    pack_avl(A,PA),
    (try_store_avl(Pref,A,PA)
    -> R='$stored_avl_packed'(ID), store_value(PA,ID)
    ; PA = packed_leaf(AP) -> R='$avl_singleton'(AP)
    ; R='$avl_packed'(PA)
).

pack_basic_fd_value(T,Nr,NewAtom) :- term_hash((T,Nr),Hash),
    pack_basic_fd_value4(Hash,T,Nr,NewAtom).

pack_bexpr(b(value(Val),T,I),b(value(PVal),T,I)) :-
    pack_value(Val,PVal).

pack_bind([],V,R) :- !, R='$bind_empty_set'(V).

pack_bind(pred_false,V,R) :- !, R='$bind_false'(V). % bind boolean values

pack_bind(pred_true,V,R) :- !, R='$bind_true'(V).

pack_bind(Val,V,'$bind'(V,PV)) :- pack_value(Val,PV).

pack_bind_list([],[],R) :- !,R=[].

pack_bind_list([bind(V,Val)|T],[V|VT],R) :- !,R=[PV|PT],
    %atom_concat(pack_,V,PackV),runtime_profiler:profile_single_call(PackV,state_packing:pack_value(Val,PV)),
    pack_value(Val,PV),
    pack_bind_list(T,VT,PT).

pack_bind_list(V,VT,R) :-
    add_internal_error('Illegal call, probably illegal order of variables: ',pack_bind_list(V,VT,R)),
    R=V.

pack_closure(P,T,Body,R) :- is_interval_closure(P,T,Body,Low,Up),!,
    %print(pack_interval(Low,Up,B)),nl,
    R='$interval'(Low,Up).

pack_closure(P,T,Body,R) :-
    (preference(use_state_packing,full) -> true ; preference(force_state_packing_for_closures,true)),
    R = '$closure'(P,T,PBody),
    %add_message(state_packing,'Packing closure: ',Body,Body),
    transform_bexpr(state_packing:pack_bexpr,Body,PBody).

pack_csp_expression(esharing(Set,B,C,Span),'$esharing'(PSet,PB,PC,PSpan)) :- !,
    pack_csp_expression(Set,PSet), pack_csp_expression(B,PB),
    pack_csp_expression(C,PC), pack_csp_expression(Span,PSpan).

pack_csp_expression('|||'(A,B,Span),'|||'(PA,PB,PSpan)) :- !,
    pack_csp_expression(A,PA), pack_csp_expression(B,PB), pack_csp_expression(Span,PSpan).

pack_csp_expression('[]'(A,B,Span),'[]'(PA,PB,PSpan)) :- !,
    pack_csp_expression(A,PA), pack_csp_expression(B,PB), pack_csp_expression(Span,PSpan).

pack_csp_expression(eaParallel(C,A,D,B,Span),eaParallel(PC,PA,PD,PB,PSpan)) :- !,
    pack_csp_expression(A,PA), pack_csp_expression(B,PB), pack_csp_expression(C,PC),
    pack_csp_expression(D,PD), pack_csp_expression(Span,PSpan).

pack_csp_expression(V,ID) :- store_value(V,ID).

pack_fd_set([fd(X,Type)|T],Type,Result) :-
    fd_type_can_be_packed_to_bv(Type),
    Acc is 1<<X,
    pack_fd_set_aux(T,Acc,Result).

pack_fd_set_aux([],A,A).

pack_fd_set_aux([fd(X,_)|T],Acc,Res) :-
    NewAcc is Acc \/ (1<<X),
    pack_fd_set_aux(T,NewAcc,Res).

pack_fields([],[]).

pack_fields([field(F,H)|T],'$field'(F,PH,PT)) :- pack_value(H,PH), pack_fields(T,PT).

pack_relation(AVL,DomSkeleton,RangeValueList) :- pack_relation(AVL,DomSkeleton,RangeValueList,[]).

pack_relation(empty, empty) --> [].

pack_relation(node((DomVal,RanVal),true,B,L0,R0), packed_rel_node(PackedVal,B,L1,R1)) -->
    {pack_value(DomVal,PackedVal),
    RanVal=RanPackedVal %pack_value(RanVal,RanPackedVal)
    }, % enable compress_bv
    [RanPackedVal],
    pack_relation(L0, L1),
    pack_relation(R0, R1).

pack_state(root,R) :- !, R=root.

pack_state(const_and_vars(ID,S),R) :- % b_or_z_mode, % here for efficiency we assume that we are in B mode; any plug-in should not use this state constructor !!
    !,
    R='$cst_vars'(ID,PCS),
    % debug:time(state_packing:pack_bind_list(S,PS)).
    (bind_skeleton(const_and_vars,Skel) -> pack_bind_list(S,Skel,PS)
    ; pack_bind_list(S,Skel,PS), %print(vskel(Skel)),nl,
    (bind_skeleton(const_and_vars,OtherList)
    -> add_internal_error('Multiple bind skeletons for const_and_vars:',OtherList:Skel) ; true),
    assertz(bind_skeleton(const_and_vars,Skel))),
    compress_list(PS,PCS).

pack_state(concrete_constants(S),R) :- preference(use_state_packing,full),
    !,
    % leads to further reduction in memory consumption, but to a slowdown
    R = '$cst'(PCS),
    (bind_skeleton(concrete_constants,Skel) -> pack_bind_list(S,Skel,PS)
    ; pack_bind_list(S,Skel,PS), %print(vskel(Skel)),nl,
    assertz(bind_skeleton(concrete_constants,Skel))),
    compress_list(PS,PCS).

pack_state([bind(V,Val)|T],R) :- % b_or_z_mode, % again, for effiency we do not check whether we are in B mode here
    !,
    R='$bind_lst'(PV1,PCT),
    pack_value(Val,PV),
    (bind_skeleton(list,[V|Skel])
    -> PV1=PV,pack_bind_list(T,Skel,PT1)
    ; pack_bind_list(T,Skel,PT),
    (bind_skeleton(list,OtherList)
    -> add_warning(pack_state,'Multiple bind skeletons:',OtherList:[V|Skel]),
    reorder(OtherList,[V|Skel],[PV|PT],[PV1|PT1]) %,print(reordered(PT1)),nl
    ; assertz(bind_skeleton(list,[V|Skel])), PT=PT1,PV=PV1
    )
    ),
    compress_list(PT1,PCT).

pack_state([],R) :- !, R=[].

pack_state(csp_and_b(CSP,B),R) :- !, R=csp_and_b(PCSP,PB),
    pack_state(CSP,PCSP),
    pack_state(B,PB).

pack_state(expanded_const_and_vars(C,V,_,_),R) :- !,
    pack_state(const_and_vars(C,V),R).

pack_state(expanded_vars(V,_),R) :- !,
    pack_state(V,R).

pack_state(CSP,R) :-
    \+ preference(use_state_packing,false),csp_mode,!,
    pack_csp_expression(CSP,PCSP), R=PCSP.

pack_state(V,V).

pack_value(Var,R) :- var(Var),!,
    add_internal_error('Illegal variable value: ', pack_value(Var,R)),
    R='$variable'(Var).

pack_value(avl_set(A),R) :- !, pack_avl_set(A,R).

pack_value((A,B),(PA,PB)) :- !, pack_value(A,PA), pack_value(B,PB).

pack_value(fd(Nr,T),R) :- pack_basic_fd_value(T,Nr,Atom),!,Atom=R.

pack_value(int(Nr),R) :- !, R=Nr.

pack_value(closure(P,T,Body),R) :- pack_closure(P,T,Body,PC),!, R=PC.

pack_value(rec(Fields),PFields) :- !, pack_fields(Fields,PFields).

pack_value(freeval(ID,Case,Val),freeval(ID,Case,PVal)) :- !, pack_value(Val,PVal).

pack_value(term(floating(Nr)),R) :- !, R=Nr.

pack_value(V,V).

pack_values([],[]) :- !.

pack_values([bind(V,Val)|T],R) :- !,R=[Bind|PT],
    pack_bind(Val,V,Bind),
    pack_values(T,PT).

pack_values(V,R) :- add_internal_error('Illegal value: ',pack_values(V,R)),R=V.

packed_avl_height(AVL, Height) :-
    packed_avl_height(AVL, 0, Height).

packed_avl_height(empty, H, H).

packed_avl_height(packed_leaf(_), H0, H1) :- H1 is H0+1.

packed_avl_height(packed_node(_,B,L,R), H0, H) :-
    H1 is H0+1,
    ( B >= 0 -> packed_avl_height(R, H1, H)
    ; packed_avl_height(L, H1, H)
).

packed_avl_height(packed_rel_node(_,_,B,L,R), H0, H) :-
    H1 is H0+1,
    ( B >= 0 -> packed_avl_height(R, H1, H)
    ; packed_avl_height(L, H1, H)
).

portray_stored_values :- bind_skeleton(Kind,Skel),
    format('Binding skeleton for ~w:~n ~w~n',[Kind,Skel]),
    fail.

portray_stored_values :-
    stored_value(NID,Value), functor(Value,F,N),
    (packed_avl_height(Value,Size) -> true ; length(Value,Size) -> true ; Size='?'),
    format('Value ~w : ~w/~w : size: ~w~n',[NID,F,N,Size]),
    fail.

portray_stored_values.

precompile_state_packing :-
    retractall(pack_basic_fd_value4(_,_,_,_)),
    retractall(unpack_basic_fd_value(_,_)),
    b_global_set(T),
    b_fd_card(T,Card),
    (integer(Card), Card < 1000 -> true
    ; debug_format(19,'Not precompiling state packing for ~w (size ~w)~n',[T,Card]),fail),
    enum_global_type_limited(fd(Nr,T),_), % limits infinite deferred sets, which we don't precompile anyway
    gen_fd_atom(Nr,T,NewAtom),
    %debug:debug_println(9,pack(T,Nr,NewAtom)),
    term_hash((T,Nr),Hash), % we could number the Types and use something like TypeNr*MaxSize + Nr
    assertz(pack_basic_fd_value4(Hash,T,Nr,NewAtom)),
    assertz(unpack_basic_fd_value(NewAtom,fd(Nr,T))),fail.

precompile_state_packing.

print_state_packing_profile :-
    (bb_get(next_value_id,Nr) -> true ; Nr=0),
    format('Stored ~w AVL sets for state compression~n',[Nr]),
    (debug_mode(on) -> portray_stored_values ; true).

print_stored_values(Stream) :- % for saving state_space to file
    print_dynamic_pred(Stream,state_packing,bind_skeleton,2),
    print_dynamic_pred(Stream,state_packing,stored_value,2),
    print_dynamic_pred(Stream,state_packing,stored_value_hash_to_id,2),
    (bb_get(next_value_id,NID) -> true ; NID=0), format(Stream,'~n:- dynamic next_value_id/1.~nnext_value_id(~w).~n~n',[NID]).

reorder([],_,_,[]).

reorder([ID|T1],Skel,Vals,[V2|T2]) :- nth1(Nr,Skel,ID), nth1(Nr,Vals,V2),!,
    reorder(T1,Skel,Vals,T2).

reorder([ID|T1],Skel,Vals,Res) :- add_internal_error('Cannot find identifier:',ID),
    reorder(T1,Skel,Vals,Res).

reset_stored_values :-
    %(retract(stored_value(ID,_)), print(remove_stored_value(ID)),nl,fail ; true),
    retractall(bind_skeleton(_,_)),
    retractall(stored_value(_,_)),
    retractall(stored_value_hash_to_id(_,_)),
    bb_put(next_value_id,0).

retract_stored_values_with_statistics :-
    retract_with_statistics(state_packing,[stored_value(_,_),
    stored_value_hash_to_id(_,_)]),
    reset_stored_values.

set_next_value_id(ID) :- bb_put(next_value_id,ID).

store_packed_avl(packed_leaf(Val)) :-
    compound(Val). % no use storing simple singleton sets; maybe singleton sets in general?

store_packed_avl(packed_node(_,_,_,_)).

store_value(Value,ID) :-
    term_hash(Value,[range(smallint),algorithm(sdbm), depth(infinite),if_var(ignore)],Hash),
    % instead of infinite we could use a lower bound, collisions are taken care of below
    store_value_aux(Value,Hash,ID).

store_value_aux(Value,Hash,ID) :-
    stored_value_hash_to_id(Hash,ID),
    stored_value(ID,Stored_Value),
    Value=Stored_Value, % check that we have the exact value, could be expensive but collisions are possible
    !. % we have already stored the value

store_value_aux(Value,Hash,ID) :-
    (bb_get(next_value_id,NID) -> true ; NID=0),
    NID1 is NID+1,
    bb_put(next_value_id,NID1),
    assertz(stored_value(NID,Value)),
    assertz(stored_value_hash_to_id(Hash,NID)),
    ID=NID.

try_store_avl(true,_A,PA) :-
    %\+ avl_height_less_than(A,5), % if the set is large enough, store it separately; TODO: provide preference?
    store_packed_avl(PA).

uncompress_bv(_,Len,Rest,Res) :- Len =< 0, !, Res=Rest.

uncompress_bv(Val,Len,Rest,[BV|TRes]) :-
    (Val mod 2 =:= 1 -> BV = pred_true ; BV=pred_false),
    Val2 is Val >> 1, Len1 is Len-1,
    uncompress_bv(Val2,Len1,Rest,TRes).

uncompress_list(l3(A,B,C,CT),[A,B,C|T]) :- !, uncompress_list(CT,T).

uncompress_list(T,T).

unpack_avl(empty,empty).

unpack_avl(packed_leaf(PackedVal), node(Val,true,0,empty,empty)) :- unpack_value(PackedVal,Val).

unpack_avl(packed_node(PackedVal,B,L0,R0), node(Val,true,B,L1,R1)) :-
    unpack_value(PackedVal,Val),
    unpack_avl(L0, L1),
    unpack_avl(R0, R1).

unpack_avl_expanded(AD,R) :-
    l_unpack_value(AD,ADT),
    custom_explicit_sets:ord_list_to_avlset_direct(ADT,R,unpack_value).

unpack_bexpr(b(value(PVal),T,I),b(value(Val),T,I)) :-
    unpack_value(PVal,Val).

unpack_bind('$bind_empty_set'(V),V,[]).

unpack_bind('$bind_false'(V),V,pred_false).

unpack_bind('$bind_true'(V),V,pred_true).

unpack_bind('$bind'(V,PV),V,Val) :- unpack_value(PV,Val).

unpack_bind_list([],[],[]).

unpack_bind_list([Val|T],[Var|VT],R) :- R=[bind(Var,UPV)|UPT],
    %atom_concat(unpack_,Var,PackV),runtime_profiler:profile_single_call(PackV,state_packing:unpack_value(Val,UPV)),
    unpack_value(Val,UPV), %!,
    unpack_bind_list(T,VT,UPT).

unpack_csp_expression('$esharing'(PSet,PB,PC,PSpan),esharing(Set,B,C,Span)) :- !,
    unpack_csp_expression(PSet,Set), unpack_csp_expression(PB,B),
    unpack_csp_expression(PC,C), unpack_csp_expression(PSpan,Span).

unpack_csp_expression('|||'(A,B,Span),'|||'(PA,PB,PSpan)) :- !,
    unpack_csp_expression(A,PA), unpack_csp_expression(B,PB), unpack_csp_expression(Span,PSpan).

unpack_csp_expression('[]'(A,B,Span),'[]'(PA,PB,PSpan)) :- !,
    unpack_csp_expression(A,PA), unpack_csp_expression(B,PB), unpack_csp_expression(Span,PSpan).

unpack_csp_expression(eaParallel(C,A,D,B,Span),eaParallel(PC,PA,PD,PB,PSpan)) :- !,
    unpack_csp_expression(A,PA), unpack_csp_expression(B,PB), unpack_csp_expression(C,PC),
    unpack_csp_expression(D,PD), unpack_csp_expression(Span,PSpan).

unpack_csp_expression(ID,V) :- !, stored_value(ID,V).

unpack_csp_expression(V,V).

unpack_fd_set(PackedInteger,Type,Value) :-
    unpack_fd_set_aux(PackedInteger,0,Type,ResList), %print(unpacked(PackedInteger,ResList)),nl,
    custom_explicit_sets:ord_list_to_avlset_direct(ResList,Value,unpack_fd_set).

unpack_fd_set_aux(0,_,_,Res) :- !, Res=[].

unpack_fd_set_aux(Nr,X,Type,Res) :-
    (Nr mod 2 =:= 1 -> Res = [fd(X,Type)-true|T] ; Res=T),
    X1 is X+1, Nr1 is (Nr>>1),
    unpack_fd_set_aux(Nr1,X1,Type,T).

unpack_fields([],[]).

unpack_fields('$field'(F,PH,PT),[field(F,H)|T]) :- unpack_value(PH,H), unpack_fields(PT,T).

unpack_relation(DomSkeleton,RangeValueList,AVL) :- unpack_relation(DomSkeleton,AVL,RangeValueList,[]).

unpack_relation(empty, empty) --> [].

unpack_relation(packed_rel_node(PackedVal,B,L1,R1), node((DomVal,RanVal),true,B,L0,R0)) -->
    {unpack_value(PackedVal,DomVal)},
    [RanPackedVal],
    {RanPackedVal=RanVal}, %{unpack_value(RanPackedVal,RanVal)},
    unpack_relation(L1, L0),
    unpack_relation(R1, R0).

unpack_state(root,State) :- !, State=root.

unpack_state(concrete_constants(C),State) :- !, State=concrete_constants(C). % comment out in case concrete_constants are packed after all

unpack_state(PackedState,State) :- %empty_avl(E), %tools_printing:print_term_summary(unpack(PackedState,State)),nl,
    %tools_printing:print_term_summary(unpack_state(PackedState)),
    unpack_state2(PackedState,State).

unpack_state2(const_and_vars(ID,CS),R) :- !,
    R=const_and_vars(ID,UPS),
    unpack_state2(CS,UPS).

unpack_state2('$cst'(CS),R) :- !,
    R=concrete_constants(UPS),
    uncompress_list(CS,S),get_bind_skeleton(concrete_constants,Skel),
    unpack_bind_list(S,Skel,UPS).

unpack_state2('$cst_vars'(ID,CS),R) :- % {b_or_z_mode}, we assume const_and_vars is only used in B or Z mode or is compatible
    !,
    R=const_and_vars(ID,UPS),
    uncompress_list(CS,S),get_bind_skeleton(const_and_vars,Skel),
    unpack_bind_list(S,Skel,UPS).

unpack_state2('$bind_lst'(Val,CT),R) :- % {b_or_z_mode}, we assume $bind_lst not used by any plug-in
    !,
    uncompress_list(CT,T),get_bind_skeleton(list,[Var|Skel]),R=[bind(Var,UPV)|RT],
    %atom_concat(unpack_,Var,PackV),runtime_profiler:profile_single_call(PackV,state_packing:unpack_value(Val,UPV)),
    unpack_value(Val,UPV), %!,
    unpack_bind_list(T,Skel,RT).

unpack_state2([],R) :- !, R=[].

unpack_state2(csp_and_b(CSP,B),csp_and_b(UPCSP,UPB)) :- !, unpack_state2(CSP,UPCSP),
    unpack_state2(B,UPB).

unpack_state2(PCSP,R) :-
    csp_mode, \+ preference(use_state_packing,false),!,
    unpack_csp_expression(PCSP,R).

unpack_state2(R,R).

unpack_state_top_level(root,State) :- !, State=root.

unpack_state_top_level(concrete_constants(C),State) :- !, State=concrete_constants(C).

unpack_state_top_level(const_and_vars(ID,CS),R) :- !, R=const_and_vars(ID,CS).

unpack_state_top_level('$cst'(CS),R) :- !, R=concrete_constants(CS).

unpack_state_top_level('$cst_vars'(ID,CS),R) :- !, R=const_and_vars(ID,CS).

unpack_state_top_level('$bind_lst'(Val,_),R) :- !, R=[bind(unknown,Val)].

unpack_state_top_level(csp_and_b(CSP,B),csp_and_b(UPCSP,UPB)) :- !, unpack_state_top_level(CSP,UPCSP),
    unpack_state_top_level(B,UPB).

unpack_state_top_level(X,X).

unpack_value(V,R) :- var(V),!,
    add_internal_error('Illegal variable value: ', unpack_value(V,R)), R=V.

unpack_value('$avl_packed'(AP),R) :- !, R=avl_set(A),unpack_avl(AP,A).

unpack_value('$avl_singleton'(AP),R) :- !, R=avl_set(node(A,true,0,empty,empty)),unpack_value(AP,A).

unpack_value('$avl_exp'(AD),R) :- !, unpack_avl_expanded(AD,R).

unpack_value('$stored_avl_packed'(ID),R) :- !,
    (stored_value(ID,Val) -> R = avl_set(A), unpack_avl(Val,A)
    ; add_internal_error('No stored AVL: ',ID),fail).

unpack_value('$stored_avl_exp'(ID),R) :- !,
    (stored_value(ID,Val) -> unpack_avl_expanded(Val,R)
    ; add_internal_error('No stored AVL: ',ID),fail).

unpack_value('$stored_avl_rel_bv_packed'(ID1,Val),R) :- !,
    (stored_value(ID1,(Len,DomVal))
    -> R = avl_set(A),
    uncompress_bv(Val,Len,[],RanVals),
    unpack_relation(DomVal,RanVals,A)
    ; add_internal_error('No stored length and Domain AVL / Range Value: ',ID1),fail).

unpack_value('$avl_bv'(PackedInteger,Type),R) :- !, unpack_fd_set(PackedInteger,Type,R).

unpack_value((A,B),(PA,PB)) :- !, unpack_value(A,PA), unpack_value(B,PB).

unpack_value('$interval'(A,B),R) :- !, construct_interval_closure(A,B,R).

unpack_value('$closure'(P,T,PB),closure(P,T,B)) :- !, transform_bexpr(state_packing:unpack_bexpr,PB,B).

unpack_value('$field'(Field,PH,PT),rec(F)) :- !,
    unpack_fields('$field'(Field,PH,PT),F).

unpack_value(freeval(ID,Case,PVal),freeval(ID,Case,Val)) :- !, unpack_value(PVal,Val).

unpack_value(Nr,R) :- integer(Nr),!, R=int(Nr).

unpack_value(Nr,R) :- float(Nr),!, R=term(floating(Nr)).

unpack_value(V,UPV) :- unpack_basic_fd_value(V,FD),!,UPV=FD.

unpack_value(V,V).

unpack_values([],[]) :- !.

unpack_values([PBind|T],R) :- unpack_bind(PBind,V,Val),!,
    R=[bind(V,Val)|UPT],
    unpack_values(T,UPT).

unpack_values(V,R) :-
    add_internal_error('Illegal value: ',unpack_values(V,R)),R=V.