diff --git a/library/gecode/3.7.3/gecode-version.txt b/library/gecode/3.7.3/gecode-version.txt new file mode 100644 index 000000000..c1e43e6d4 --- /dev/null +++ b/library/gecode/3.7.3/gecode-version.txt @@ -0,0 +1 @@ +3.7.3 diff --git a/library/gecode/3.7.3/gecode_yap_auto_generated.yap b/library/gecode/3.7.3/gecode_yap_auto_generated.yap new file mode 100644 index 000000000..1b519c648 --- /dev/null +++ b/library/gecode/3.7.3/gecode_yap_auto_generated.yap @@ -0,0 +1,2995 @@ +%% -*- prolog -*- +%%============================================================================= +%% Copyright (C) 2011 by Denys Duchier +%% +%% This program is free software: you can redistribute it and/or modify it +%% under the terms of the GNU Lesser General Public License as published by the +%% Free Software Foundation, either version 3 of the License, or (at your +%% option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +%% more details. +%% +%% You should have received a copy of the GNU Lesser General Public License +%% along with this program. If not, see . +%%============================================================================= + +is_IntRelType_('IRT_EQ'). +is_IntRelType_('IRT_NQ'). +is_IntRelType_('IRT_LQ'). +is_IntRelType_('IRT_LE'). +is_IntRelType_('IRT_GQ'). +is_IntRelType_('IRT_GR'). + +is_IntRelType_('IRT_EQ','IRT_EQ'). +is_IntRelType_('IRT_NQ','IRT_NQ'). +is_IntRelType_('IRT_LQ','IRT_LQ'). +is_IntRelType_('IRT_LE','IRT_LE'). +is_IntRelType_('IRT_GQ','IRT_GQ'). +is_IntRelType_('IRT_GR','IRT_GR'). + +is_IntRelType(X,Y) :- nonvar(X), is_IntRelType_(X,Y). +is_IntRelType(X) :- is_IntRelType(X,_). + +is_BoolOpType_('BOT_AND'). +is_BoolOpType_('BOT_OR'). +is_BoolOpType_('BOT_IMP'). +is_BoolOpType_('BOT_EQV'). +is_BoolOpType_('BOT_XOR'). + +is_BoolOpType_('BOT_AND','BOT_AND'). +is_BoolOpType_('BOT_OR','BOT_OR'). +is_BoolOpType_('BOT_IMP','BOT_IMP'). +is_BoolOpType_('BOT_EQV','BOT_EQV'). +is_BoolOpType_('BOT_XOR','BOT_XOR'). + +is_BoolOpType(X,Y) :- nonvar(X), is_BoolOpType_(X,Y). +is_BoolOpType(X) :- is_BoolOpType(X,_). + +is_IntConLevel_('ICL_VAL'). +is_IntConLevel_('ICL_BND'). +is_IntConLevel_('ICL_DOM'). +is_IntConLevel_('ICL_DEF'). + +is_IntConLevel_('ICL_VAL','ICL_VAL'). +is_IntConLevel_('ICL_BND','ICL_BND'). +is_IntConLevel_('ICL_DOM','ICL_DOM'). +is_IntConLevel_('ICL_DEF','ICL_DEF'). + +is_IntConLevel(X,Y) :- nonvar(X), is_IntConLevel_(X,Y). +is_IntConLevel(X) :- is_IntConLevel(X,_). + +is_TaskType_('TT_FIXP'). +is_TaskType_('TT_FIXS'). +is_TaskType_('TT_FIXE'). + +is_TaskType_('TT_FIXP','TT_FIXP'). +is_TaskType_('TT_FIXS','TT_FIXS'). +is_TaskType_('TT_FIXE','TT_FIXE'). + +is_TaskType(X,Y) :- nonvar(X), is_TaskType_(X,Y). +is_TaskType(X) :- is_TaskType(X,_). + +is_ExtensionalPropKind_('EPK_DEF'). +is_ExtensionalPropKind_('EPK_SPEED'). +is_ExtensionalPropKind_('EPK_MEMORY'). + +is_ExtensionalPropKind_('EPK_DEF','EPK_DEF'). +is_ExtensionalPropKind_('EPK_SPEED','EPK_SPEED'). +is_ExtensionalPropKind_('EPK_MEMORY','EPK_MEMORY'). + +is_ExtensionalPropKind(X,Y) :- nonvar(X), is_ExtensionalPropKind_(X,Y). +is_ExtensionalPropKind(X) :- is_ExtensionalPropKind(X,_). + +is_IntVarBranch_('INT_VAR_NONE'). +is_IntVarBranch_('INT_VAR_RND'). +is_IntVarBranch_('INT_VAR_DEGREE_MIN'). +is_IntVarBranch_('INT_VAR_DEGREE_MAX'). +is_IntVarBranch_('INT_VAR_AFC_MIN'). +is_IntVarBranch_('INT_VAR_AFC_MAX'). +is_IntVarBranch_('INT_VAR_MIN_MIN'). +is_IntVarBranch_('INT_VAR_MIN_MAX'). +is_IntVarBranch_('INT_VAR_MAX_MIN'). +is_IntVarBranch_('INT_VAR_MAX_MAX'). +is_IntVarBranch_('INT_VAR_SIZE_MIN'). +is_IntVarBranch_('INT_VAR_SIZE_MAX'). +is_IntVarBranch_('INT_VAR_SIZE_DEGREE_MIN'). +is_IntVarBranch_('INT_VAR_SIZE_DEGREE_MAX'). +is_IntVarBranch_('INT_VAR_SIZE_AFC_MIN'). +is_IntVarBranch_('INT_VAR_SIZE_AFC_MAX'). +is_IntVarBranch_('INT_VAR_REGRET_MIN_MIN'). +is_IntVarBranch_('INT_VAR_REGRET_MIN_MAX'). +is_IntVarBranch_('INT_VAR_REGRET_MAX_MIN'). +is_IntVarBranch_('INT_VAR_REGRET_MAX_MAX'). + +is_IntVarBranch_('INT_VAR_NONE','INT_VAR_NONE'). +is_IntVarBranch_('INT_VAR_RND','INT_VAR_RND'). +is_IntVarBranch_('INT_VAR_DEGREE_MIN','INT_VAR_DEGREE_MIN'). +is_IntVarBranch_('INT_VAR_DEGREE_MAX','INT_VAR_DEGREE_MAX'). +is_IntVarBranch_('INT_VAR_AFC_MIN','INT_VAR_AFC_MIN'). +is_IntVarBranch_('INT_VAR_AFC_MAX','INT_VAR_AFC_MAX'). +is_IntVarBranch_('INT_VAR_MIN_MIN','INT_VAR_MIN_MIN'). +is_IntVarBranch_('INT_VAR_MIN_MAX','INT_VAR_MIN_MAX'). +is_IntVarBranch_('INT_VAR_MAX_MIN','INT_VAR_MAX_MIN'). +is_IntVarBranch_('INT_VAR_MAX_MAX','INT_VAR_MAX_MAX'). +is_IntVarBranch_('INT_VAR_SIZE_MIN','INT_VAR_SIZE_MIN'). +is_IntVarBranch_('INT_VAR_SIZE_MAX','INT_VAR_SIZE_MAX'). +is_IntVarBranch_('INT_VAR_SIZE_DEGREE_MIN','INT_VAR_SIZE_DEGREE_MIN'). +is_IntVarBranch_('INT_VAR_SIZE_DEGREE_MAX','INT_VAR_SIZE_DEGREE_MAX'). +is_IntVarBranch_('INT_VAR_SIZE_AFC_MIN','INT_VAR_SIZE_AFC_MIN'). +is_IntVarBranch_('INT_VAR_SIZE_AFC_MAX','INT_VAR_SIZE_AFC_MAX'). +is_IntVarBranch_('INT_VAR_REGRET_MIN_MIN','INT_VAR_REGRET_MIN_MIN'). +is_IntVarBranch_('INT_VAR_REGRET_MIN_MAX','INT_VAR_REGRET_MIN_MAX'). +is_IntVarBranch_('INT_VAR_REGRET_MAX_MIN','INT_VAR_REGRET_MAX_MIN'). +is_IntVarBranch_('INT_VAR_REGRET_MAX_MAX','INT_VAR_REGRET_MAX_MAX'). + +is_IntVarBranch(X,Y) :- nonvar(X), is_IntVarBranch_(X,Y). +is_IntVarBranch(X) :- is_IntVarBranch(X,_). + +is_IntValBranch_('INT_VAL_MIN'). +is_IntValBranch_('INT_VAL_MED'). +is_IntValBranch_('INT_VAL_MAX'). +is_IntValBranch_('INT_VAL_RND'). +is_IntValBranch_('INT_VAL_SPLIT_MIN'). +is_IntValBranch_('INT_VAL_SPLIT_MAX'). +is_IntValBranch_('INT_VAL_RANGE_MIN'). +is_IntValBranch_('INT_VAL_RANGE_MAX'). +is_IntValBranch_('INT_VALUES_MIN'). +is_IntValBranch_('INT_VALUES_MAX'). + +is_IntValBranch_('INT_VAL_MIN','INT_VAL_MIN'). +is_IntValBranch_('INT_VAL_MED','INT_VAL_MED'). +is_IntValBranch_('INT_VAL_MAX','INT_VAL_MAX'). +is_IntValBranch_('INT_VAL_RND','INT_VAL_RND'). +is_IntValBranch_('INT_VAL_SPLIT_MIN','INT_VAL_SPLIT_MIN'). +is_IntValBranch_('INT_VAL_SPLIT_MAX','INT_VAL_SPLIT_MAX'). +is_IntValBranch_('INT_VAL_RANGE_MIN','INT_VAL_RANGE_MIN'). +is_IntValBranch_('INT_VAL_RANGE_MAX','INT_VAL_RANGE_MAX'). +is_IntValBranch_('INT_VALUES_MIN','INT_VALUES_MIN'). +is_IntValBranch_('INT_VALUES_MAX','INT_VALUES_MAX'). + +is_IntValBranch(X,Y) :- nonvar(X), is_IntValBranch_(X,Y). +is_IntValBranch(X) :- is_IntValBranch(X,_). + +is_IntAssign_('INT_ASSIGN_MIN'). +is_IntAssign_('INT_ASSIGN_MED'). +is_IntAssign_('INT_ASSIGN_MAX'). +is_IntAssign_('INT_ASSIGN_RND'). + +is_IntAssign_('INT_ASSIGN_MIN','INT_ASSIGN_MIN'). +is_IntAssign_('INT_ASSIGN_MED','INT_ASSIGN_MED'). +is_IntAssign_('INT_ASSIGN_MAX','INT_ASSIGN_MAX'). +is_IntAssign_('INT_ASSIGN_RND','INT_ASSIGN_RND'). + +is_IntAssign(X,Y) :- nonvar(X), is_IntAssign_(X,Y). +is_IntAssign(X) :- is_IntAssign(X,_). + +is_SetRelType_('SRT_EQ'). +is_SetRelType_('SRT_NQ'). +is_SetRelType_('SRT_SUB'). +is_SetRelType_('SRT_SUP'). +is_SetRelType_('SRT_DISJ'). +is_SetRelType_('SRT_CMPL'). +is_SetRelType_('SRT_LQ'). +is_SetRelType_('SRT_LE'). +is_SetRelType_('SRT_GQ'). +is_SetRelType_('SRT_GR'). + +is_SetRelType_('SRT_EQ','SRT_EQ'). +is_SetRelType_('SRT_NQ','SRT_NQ'). +is_SetRelType_('SRT_SUB','SRT_SUB'). +is_SetRelType_('SRT_SUP','SRT_SUP'). +is_SetRelType_('SRT_DISJ','SRT_DISJ'). +is_SetRelType_('SRT_CMPL','SRT_CMPL'). +is_SetRelType_('SRT_LQ','SRT_LQ'). +is_SetRelType_('SRT_LE','SRT_LE'). +is_SetRelType_('SRT_GQ','SRT_GQ'). +is_SetRelType_('SRT_GR','SRT_GR'). + +is_SetRelType(X,Y) :- nonvar(X), is_SetRelType_(X,Y). +is_SetRelType(X) :- is_SetRelType(X,_). + +is_SetOpType_('SOT_UNION'). +is_SetOpType_('SOT_DUNION'). +is_SetOpType_('SOT_INTER'). +is_SetOpType_('SOT_MINUS'). + +is_SetOpType_('SOT_UNION','SOT_UNION'). +is_SetOpType_('SOT_DUNION','SOT_DUNION'). +is_SetOpType_('SOT_INTER','SOT_INTER'). +is_SetOpType_('SOT_MINUS','SOT_MINUS'). + +is_SetOpType(X,Y) :- nonvar(X), is_SetOpType_(X,Y). +is_SetOpType(X) :- is_SetOpType(X,_). + +is_SetVarBranch_('SET_VAR_NONE'). +is_SetVarBranch_('SET_VAR_RND'). +is_SetVarBranch_('SET_VAR_DEGREE_MIN'). +is_SetVarBranch_('SET_VAR_DEGREE_MAX'). +is_SetVarBranch_('SET_VAR_AFC_MIN'). +is_SetVarBranch_('SET_VAR_AFC_MAX'). +is_SetVarBranch_('SET_VAR_MIN_MIN'). +is_SetVarBranch_('SET_VAR_MIN_MAX'). +is_SetVarBranch_('SET_VAR_MAX_MIN'). +is_SetVarBranch_('SET_VAR_MAX_MAX'). +is_SetVarBranch_('SET_VAR_SIZE_MIN'). +is_SetVarBranch_('SET_VAR_SIZE_MAX'). +is_SetVarBranch_('SET_VAR_SIZE_DEGREE_MIN'). +is_SetVarBranch_('SET_VAR_SIZE_DEGREE_MAX'). +is_SetVarBranch_('SET_VAR_SIZE_AFC_MIN'). +is_SetVarBranch_('SET_VAR_SIZE_AFC_MAX'). + +is_SetVarBranch_('SET_VAR_NONE','SET_VAR_NONE'). +is_SetVarBranch_('SET_VAR_RND','SET_VAR_RND'). +is_SetVarBranch_('SET_VAR_DEGREE_MIN','SET_VAR_DEGREE_MIN'). +is_SetVarBranch_('SET_VAR_DEGREE_MAX','SET_VAR_DEGREE_MAX'). +is_SetVarBranch_('SET_VAR_AFC_MIN','SET_VAR_AFC_MIN'). +is_SetVarBranch_('SET_VAR_AFC_MAX','SET_VAR_AFC_MAX'). +is_SetVarBranch_('SET_VAR_MIN_MIN','SET_VAR_MIN_MIN'). +is_SetVarBranch_('SET_VAR_MIN_MAX','SET_VAR_MIN_MAX'). +is_SetVarBranch_('SET_VAR_MAX_MIN','SET_VAR_MAX_MIN'). +is_SetVarBranch_('SET_VAR_MAX_MAX','SET_VAR_MAX_MAX'). +is_SetVarBranch_('SET_VAR_SIZE_MIN','SET_VAR_SIZE_MIN'). +is_SetVarBranch_('SET_VAR_SIZE_MAX','SET_VAR_SIZE_MAX'). +is_SetVarBranch_('SET_VAR_SIZE_DEGREE_MIN','SET_VAR_SIZE_DEGREE_MIN'). +is_SetVarBranch_('SET_VAR_SIZE_DEGREE_MAX','SET_VAR_SIZE_DEGREE_MAX'). +is_SetVarBranch_('SET_VAR_SIZE_AFC_MIN','SET_VAR_SIZE_AFC_MIN'). +is_SetVarBranch_('SET_VAR_SIZE_AFC_MAX','SET_VAR_SIZE_AFC_MAX'). + +is_SetVarBranch(X,Y) :- nonvar(X), is_SetVarBranch_(X,Y). +is_SetVarBranch(X) :- is_SetVarBranch(X,_). + +is_SetValBranch_('SET_VAL_MIN_INC'). +is_SetValBranch_('SET_VAL_MIN_EXC'). +is_SetValBranch_('SET_VAL_MED_INC'). +is_SetValBranch_('SET_VAL_MED_EXC'). +is_SetValBranch_('SET_VAL_MAX_INC'). +is_SetValBranch_('SET_VAL_MAX_EXC'). +is_SetValBranch_('SET_VAL_RND_INC'). +is_SetValBranch_('SET_VAL_RND_EXC'). + +is_SetValBranch_('SET_VAL_MIN_INC','SET_VAL_MIN_INC'). +is_SetValBranch_('SET_VAL_MIN_EXC','SET_VAL_MIN_EXC'). +is_SetValBranch_('SET_VAL_MED_INC','SET_VAL_MED_INC'). +is_SetValBranch_('SET_VAL_MED_EXC','SET_VAL_MED_EXC'). +is_SetValBranch_('SET_VAL_MAX_INC','SET_VAL_MAX_INC'). +is_SetValBranch_('SET_VAL_MAX_EXC','SET_VAL_MAX_EXC'). +is_SetValBranch_('SET_VAL_RND_INC','SET_VAL_RND_INC'). +is_SetValBranch_('SET_VAL_RND_EXC','SET_VAL_RND_EXC'). + +is_SetValBranch(X,Y) :- nonvar(X), is_SetValBranch_(X,Y). +is_SetValBranch(X) :- is_SetValBranch(X,_). + +is_SetAssign_('SET_ASSIGN_MIN_INC'). +is_SetAssign_('SET_ASSIGN_MIN_EXC'). +is_SetAssign_('SET_ASSIGN_MED_INC'). +is_SetAssign_('SET_ASSIGN_MED_EXC'). +is_SetAssign_('SET_ASSIGN_MAX_INC'). +is_SetAssign_('SET_ASSIGN_MAX_EXC'). +is_SetAssign_('SET_ASSIGN_RND_INC'). +is_SetAssign_('SET_ASSIGN_RND_EXC'). + +is_SetAssign_('SET_ASSIGN_MIN_INC','SET_ASSIGN_MIN_INC'). +is_SetAssign_('SET_ASSIGN_MIN_EXC','SET_ASSIGN_MIN_EXC'). +is_SetAssign_('SET_ASSIGN_MED_INC','SET_ASSIGN_MED_INC'). +is_SetAssign_('SET_ASSIGN_MED_EXC','SET_ASSIGN_MED_EXC'). +is_SetAssign_('SET_ASSIGN_MAX_INC','SET_ASSIGN_MAX_INC'). +is_SetAssign_('SET_ASSIGN_MAX_EXC','SET_ASSIGN_MAX_EXC'). +is_SetAssign_('SET_ASSIGN_RND_INC','SET_ASSIGN_RND_INC'). +is_SetAssign_('SET_ASSIGN_RND_EXC','SET_ASSIGN_RND_EXC'). + +is_SetAssign(X,Y) :- nonvar(X), is_SetAssign_(X,Y). +is_SetAssign(X) :- is_SetAssign(X,_). + +unary(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_TaskTypeArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_BoolVarArgs(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_unary_357(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_BoolVarArgs(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_unary_353(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=1))). + +nvalues(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_nvalues_255(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_nvalues_257(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_nvalues_251(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_nvalues_253(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=1))). + +max(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_max_218(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_max_217(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> gecode_constraint_max_221(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=2))))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=1))). + +dom(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_dom_139(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> gecode_constraint_dom_149(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=1))). + +convex(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_SetVar(X2,Y2) + -> gecode_constraint_convex_51(Y0,Y1,Y2) + ; throw(gecode_argument_error(convex(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(convex(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(convex(X0,X1,X2),arg=1))). + +nooverlap(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> gecode_constraint_nooverlap_242(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=1))). + +assign(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolVarArgs(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> gecode_constraint_assign_4(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> gecode_constraint_assign_3(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> gecode_constraint_assign_5(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_IntVar(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> gecode_constraint_assign_7(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetAssign(X2,Y2) + -> gecode_constraint_assign_6(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetAssign(X2,Y2) + -> gecode_constraint_assign_8(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=2)))))))) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=1))). + +element(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_element_158(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_element_162(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_element_152(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_element_150(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; (is_IntSetArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_SetVar(X3,Y3) + -> gecode_constraint_element_157(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_SetVar(X3,Y3) + -> gecode_constraint_element_165(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_element_168(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_element_174(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_element_166(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=2))))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=1))). + +sequence(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> gecode_constraint_sequence_338(Y0,Y1) + ; throw(gecode_argument_error(sequence(X0,X1),arg=2))) + ; throw(gecode_argument_error(sequence(X0,X1),arg=1))). + +notMax(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_notMax_248(Y0,Y1,Y2) + ; throw(gecode_argument_error(notMax(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(notMax(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(notMax(X0,X1,X2),arg=1))). + +unary(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> gecode_constraint_unary_350(Y0,Y1,Y2) + ; throw(gecode_argument_error(unary(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(unary(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(unary(X0,X1,X2),arg=1))). + +circuit(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_circuit_45(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_circuit_36(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=1))). + +dom(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_dom_138(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_dom_143(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5)))) + ; (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_dom_137(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4)))) + ; (is_IntSet(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_dom_133(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=3)))) + ; (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_dom_131(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_dom_148(Y0,Y1,Y2,Y3,Y4) + ; (is_BoolVar(X4,Y4) + -> gecode_constraint_dom_147(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5)))) + ; (is_IntSet(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_dom_145(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=2))))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=1))). + +channel(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_channel_32(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_channel_27(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_channel_23(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_channel_21(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=2)))))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=1))). + +nooverlap(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntVarArgs(X6,Y6) + -> (is_BoolVarArgs(X7,Y7) + -> gecode_constraint_nooverlap_244(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; (is_IntConLevel(X7,Y7) + -> gecode_constraint_nooverlap_247(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=8)))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +element(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntVar(X6,Y6) + -> gecode_constraint_element_160(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_BoolVar(X6,Y6) + -> gecode_constraint_element_154(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_IntSetArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_SetVar(X6,Y6) + -> gecode_constraint_element_156(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_SetVar(X6,Y6) + -> gecode_constraint_element_164(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntVar(X6,Y6) + -> gecode_constraint_element_172(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_BoolVar(X6,Y6) + -> gecode_constraint_element_170(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=2))))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +max(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_max_216(Y0,Y1,Y2) + ; throw(gecode_argument_error(max(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_max_220(Y0,Y1,Y2) + ; throw(gecode_argument_error(max(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(max(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(max(X0,X1,X2),arg=1))). + +unshare(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> gecode_constraint_unshare_362(Y0,Y1) + ; (is_BoolVarArgs(X1,Y1) + -> gecode_constraint_unshare_360(Y0,Y1) + ; throw(gecode_argument_error(unshare(X0,X1),arg=2)))) + ; throw(gecode_argument_error(unshare(X0,X1),arg=1))). + +path(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_path_268(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_path_267(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=1))). + +mult(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_mult_238(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=1))). + +clause(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolOpType(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> (is_BoolVarArgs(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_clause_49(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_clause_47(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=1))). + +precede(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_precede_273(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=1))). + +distinct(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> gecode_constraint_distinct_120(Y0,Y1) + ; throw(gecode_argument_error(distinct(X0,X1),arg=2))) + ; throw(gecode_argument_error(distinct(X0,X1),arg=1))). + +member(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> gecode_constraint_member_226(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_member_229(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> gecode_constraint_member_222(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_member_225(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=1))). + +mod(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_mod_237(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=1))). + +cardinality(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_cardinality_18(Y0,Y1,Y2) + ; throw(gecode_argument_error(cardinality(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2),arg=1))). + +atmostOne(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> gecode_constraint_atmostOne_9(Y0,Y1,Y2) + ; throw(gecode_argument_error(atmostOne(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(atmostOne(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(atmostOne(X0,X1,X2),arg=1))). + +channelSorted(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_SetVar(X2,Y2) + -> gecode_constraint_channelSorted_33(Y0,Y1,Y2) + ; throw(gecode_argument_error(channelSorted(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(channelSorted(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(channelSorted(X0,X1,X2),arg=1))). + +linear(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_linear_210(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_linear_214(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_linear_186(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_linear_190(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=1))). + +circuit(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> gecode_constraint_circuit_42(Y0,Y1) + ; throw(gecode_argument_error(circuit(X0,X1),arg=2))) + ; throw(gecode_argument_error(circuit(X0,X1),arg=1))). + +rel(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_288(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_291(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))) + ; (is_BoolVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_284(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_287(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))) + ; (is_BoolOpType(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_rel_282(Y0,Y1,Y2,Y3,Y4) + ; (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_280(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3)))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_299(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; (is_BoolVarArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_295(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_293(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3))) + ; (is_SetOpType(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> (is_IntSet(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_rel_323(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntSet(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_rel_321(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3)))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_307(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_309(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVarArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_303(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_310(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_313(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))) + ; (is_IntVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_314(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_317(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))) + ; (is_SetRelType(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_320(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3)))) + ; (is_SetVar(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_331(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; (is_SetVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_333(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolOpType(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_279(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_277(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=2))))))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=1))). + +min(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_min_232(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_min_231(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> gecode_constraint_min_235(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=2))))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=1))). + +cardinality(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_cardinality_19(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=1))). + +count(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_count_69(Y0,Y1,Y2,Y3) + ; (is_IntArgs(X3,Y3) + -> gecode_constraint_count_66(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=4)))) + ; (is_IntSet(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> gecode_constraint_count_60(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=4))) + ; (is_IntSetArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_count_59(Y0,Y1,Y2,Y3) + ; (is_IntArgs(X3,Y3) + -> gecode_constraint_count_56(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=3))))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=1))). + +sqrt(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_sqrt_346(Y0,Y1,Y2) + ; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=1))). + +cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_117(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_115(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_113(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_111(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=4)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_109(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_107(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_105(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_103(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=4)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=3))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=2)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=1))). + +nvalues(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_nvalues_254(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_nvalues_256(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_nvalues_250(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_nvalues_252(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=1))). + +binpacking(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> gecode_constraint_binpacking_10(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3),arg=1))). + +linear(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_linear_201(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_linear_205(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=5)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_BoolVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_linear_193(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_linear_197(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=5)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=2))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +abs(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_abs_2(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(abs(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(abs(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(abs(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(abs(X0,X1,X2,X3),arg=1))). + +convex(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> gecode_constraint_convex_50(Y0,Y1) + ; throw(gecode_argument_error(convex(X0,X1),arg=2))) + ; throw(gecode_argument_error(convex(X0,X1),arg=1))). + +div(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_div_122(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=1))). + +rel(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_311(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_315(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntSet(X1,Y1) + -> (is_SetOpType(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetRelType(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_rel_300(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_SetVar(X5,Y5) + -> gecode_constraint_rel_301(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_289(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_BoolVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_285(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4)))) + ; (is_BoolOpType(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_283(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_281(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=3)))) + ; (is_SetVar(X1,Y1) + -> (is_SetOpType(X2,Y2) + -> (is_IntSet(X3,Y3) + -> (is_SetRelType(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_rel_326(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_SetVar(X5,Y5) + -> gecode_constraint_rel_327(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_SetVar(X3,Y3) + -> (is_SetRelType(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_rel_328(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_SetVar(X5,Y5) + -> gecode_constraint_rel_329(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=2)))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=1))). + +weights(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_weights_364(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=1))). + +max(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_max_219(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=1))). + +path(X0,X1,X2,X3,X4,X5,X6,X7,X8) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntVarArgs(X6,Y6) + -> (is_IntVar(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_path_263(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=3))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=2))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=1))). + +unary(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_TaskTypeArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> gecode_constraint_unary_358(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> gecode_constraint_unary_354(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_BoolVarArgs(X3,Y3) + -> gecode_constraint_unary_348(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_unary_351(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=3)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=1))). + +sorted(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_sorted_341(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=1))). + +circuit(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_circuit_40(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_circuit_37(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_circuit_34(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=3)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=1))). + +dom(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_dom_142(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_dom_136(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_141(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))))) + ; (is_IntSet(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> gecode_constraint_dom_132(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_135(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3)))) + ; (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_dom_130(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_129(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))) + ; (is_IntSet(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_127(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3)))) + ; (is_SetVar(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_dom_146(Y0,Y1,Y2,Y3) + ; (is_IntSet(X3,Y3) + -> gecode_constraint_dom_144(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=2))))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=1))). + +abs(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_abs_1(Y0,Y1,Y2) + ; throw(gecode_argument_error(abs(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(abs(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(abs(X0,X1,X2),arg=1))). + +channel(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_channel_29(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_channel_24(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=1))). + +rel(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> gecode_constraint_rel_304(Y0,Y1,Y2) + ; throw(gecode_argument_error(rel(X0,X1,X2),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> gecode_constraint_rel_296(Y0,Y1,Y2) + ; throw(gecode_argument_error(rel(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(rel(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(rel(X0,X1,X2),arg=1))). + +path(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_path_266(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(path(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3),arg=1))). + +branch(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> gecode_constraint_branch_14(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> gecode_constraint_branch_13(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetVarBranch(X2,Y2) + -> (is_SetValBranch(X3,Y3) + -> gecode_constraint_branch_15(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=2))))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=1))). + +mult(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_mult_239(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=1))). + +circuit(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_circuit_41(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVarArgs(X4,Y4) + -> (is_IntVar(X5,Y5) + -> gecode_constraint_circuit_38(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_circuit_35(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=3)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=1))). + +clause(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolOpType(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> (is_BoolVarArgs(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_clause_48(Y0,Y1,Y2,Y3,Y4) + ; (is_BoolVar(X4,Y4) + -> gecode_constraint_clause_46(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=1))). + +precede(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_precede_275(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_precede_272(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_precede_271(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=3)))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=1))). + +channel(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_channel_30(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=1))). + +cumulative(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> gecode_constraint_cumulative_86(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_89(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> gecode_constraint_cumulative_82(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_85(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_79(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=4)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; (is_IntVar(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> gecode_constraint_cumulative_98(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_101(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> gecode_constraint_cumulative_94(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_97(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_91(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=4)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=2)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +distinct(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntConLevel(X2,Y2) + -> gecode_constraint_distinct_121(Y0,Y1,Y2) + ; throw(gecode_argument_error(distinct(X0,X1,X2),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> gecode_constraint_distinct_118(Y0,Y1,Y2) + ; throw(gecode_argument_error(distinct(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(distinct(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(distinct(X0,X1,X2),arg=1))). + +member(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_member_227(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_member_223(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=1))). + +mod(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_mod_236(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3),arg=1))). + +sqr(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_sqr_344(Y0,Y1,Y2) + ; throw(gecode_argument_error(sqr(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(sqr(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(sqr(X0,X1,X2),arg=1))). + +sequence(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntSet(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_sequence_337(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntSet(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_sequence_335(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=2)))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +path(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntVar(X6,Y6) + -> gecode_constraint_path_264(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_path_261(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; (is_IntVarArgs(X5,Y5) + -> (is_IntVar(X6,Y6) + -> gecode_constraint_path_258(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=6)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=2))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +divmod(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_divmod_125(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=1))). + +sorted(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> gecode_constraint_sorted_342(Y0,Y1,Y2) + ; throw(gecode_argument_error(sorted(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(sorted(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(sorted(X0,X1,X2),arg=1))). + +circuit(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> gecode_constraint_circuit_44(Y0,Y1,Y2) + ; throw(gecode_argument_error(circuit(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntConLevel(X2,Y2) + -> gecode_constraint_circuit_43(Y0,Y1,Y2) + ; throw(gecode_argument_error(circuit(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(circuit(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2),arg=1))). + +channel(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> gecode_constraint_channel_31(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> gecode_constraint_channel_28(Y0,Y1,Y2) + ; (is_IntVarArgs(X2,Y2) + -> gecode_constraint_channel_26(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3)))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_channel_22(Y0,Y1,Y2) + ; (is_SetVar(X2,Y2) + -> gecode_constraint_channel_25(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3)))) + ; (is_BoolVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_channel_20(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=2)))))) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=1))). + +count(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_count_52(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_count_54(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; (is_int(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_count_70(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_count_72(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntSet(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_count_62(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_count_64(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5)))) + ; (is_IntArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_count_61(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4)))) + ; (is_IntSetArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_count_57(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_count_67(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVar(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_count_74(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_count_76(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=3)))))))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=1))). + +cumulatives(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_116(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_114(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_112(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_110(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=4)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_108(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_106(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_104(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_102(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=4)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=2)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +binpacking(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_binpacking_11(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=1))). + +linear(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_209(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_213(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_185(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_189(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> gecode_constraint_linear_200(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_203(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))) + ; (is_IntVar(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> gecode_constraint_linear_204(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_207(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_BoolVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> gecode_constraint_linear_192(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_195(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))) + ; (is_IntVar(X4,Y4) + -> (is_BoolVar(X5,Y5) + -> gecode_constraint_linear_196(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_199(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=3)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=2))))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=1))). + +nooverlap(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntVarArgs(X6,Y6) + -> gecode_constraint_nooverlap_246(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_nooverlap_241(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +div(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_div_123(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=1))). + +sqr(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_sqr_345(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(sqr(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(sqr(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(sqr(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(sqr(X0,X1,X2,X3),arg=1))). + +path(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_path_265(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; (is_IntVarArgs(X6,Y6) + -> (is_IntVar(X7,Y7) + -> gecode_constraint_path_262(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=7)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_path_259(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=3)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=2))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +unary(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_TaskTypeArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_BoolVarArgs(X4,Y4) + -> gecode_constraint_unary_356(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_unary_359(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_BoolVarArgs(X4,Y4) + -> gecode_constraint_unary_352(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_unary_355(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_BoolVarArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_unary_349(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=3)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=1))). + +sorted(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> gecode_constraint_sorted_340(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_sorted_343(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3),arg=1))). + +element(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_element_161(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_BoolVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_element_155(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_element_173(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; (is_BoolVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_element_171(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=7)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=2))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +element(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_159(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_163(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_153(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_151(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=3))) + ; (is_SetOpType(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_element_182(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_element_180(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntSetArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_element_178(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_element_176(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=3)))))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_169(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_175(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_167(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=2)))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=1))). + +sequence(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_SetVar(X2,Y2) + -> gecode_constraint_sequence_339(Y0,Y1,Y2) + ; throw(gecode_argument_error(sequence(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(sequence(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(sequence(X0,X1,X2),arg=1))). + +circuit(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_circuit_39(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=2))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +precede(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> gecode_constraint_precede_274(Y0,Y1,Y2) + ; throw(gecode_argument_error(precede(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> gecode_constraint_precede_270(Y0,Y1,Y2) + ; throw(gecode_argument_error(precede(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(precede(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(precede(X0,X1,X2),arg=1))). + +cumulative(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> gecode_constraint_cumulative_88(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> gecode_constraint_cumulative_84(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> gecode_constraint_cumulative_78(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_cumulative_81(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=4)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=3)))) + ; (is_IntVar(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> gecode_constraint_cumulative_100(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> gecode_constraint_cumulative_96(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> gecode_constraint_cumulative_90(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_cumulative_93(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=4)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=3)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=1))). + +distinct(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_distinct_119(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(distinct(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(distinct(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(distinct(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(distinct(X0,X1,X2,X3),arg=1))). + +min(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_min_230(Y0,Y1,Y2) + ; throw(gecode_argument_error(min(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_min_234(Y0,Y1,Y2) + ; throw(gecode_argument_error(min(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(min(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(min(X0,X1,X2),arg=1))). + +sqrt(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_sqrt_347(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(sqrt(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(sqrt(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(sqrt(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(sqrt(X0,X1,X2,X3),arg=1))). + +sequence(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntSet(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_int(X5,Y5) + -> gecode_constraint_sequence_336(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntSet(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_int(X5,Y5) + -> gecode_constraint_sequence_334(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=1))). + +unshare(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntConLevel(X2,Y2) + -> gecode_constraint_unshare_363(Y0,Y1,Y2) + ; throw(gecode_argument_error(unshare(X0,X1,X2),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntConLevel(X2,Y2) + -> gecode_constraint_unshare_361(Y0,Y1,Y2) + ; throw(gecode_argument_error(unshare(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(unshare(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(unshare(X0,X1,X2),arg=1))). + +path(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_path_269(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> gecode_constraint_path_260(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=1))). + +divmod(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_divmod_124(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=1))). + +nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntVarArgs(X6,Y6) + -> (is_BoolVarArgs(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_nooverlap_245(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=4))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=3))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=1))). + +cumulative(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> gecode_constraint_cumulative_80(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntVar(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> gecode_constraint_cumulative_92(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=1))). + +member(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_member_228(Y0,Y1,Y2) + ; throw(gecode_argument_error(member(X0,X1,X2),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> gecode_constraint_member_224(Y0,Y1,Y2) + ; throw(gecode_argument_error(member(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(member(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(member(X0,X1,X2),arg=1))). + +count(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_71(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_73(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVar(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_75(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_77(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntSet(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_63(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_65(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_53(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_55(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=3)))))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=1))). + +notMin(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_notMin_249(Y0,Y1,Y2) + ; throw(gecode_argument_error(notMin(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(notMin(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(notMin(X0,X1,X2),arg=1))). + +cumulative(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_cumulative_87(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_cumulative_83(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=3)))) + ; (is_IntVar(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_cumulative_99(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_cumulative_95(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=3)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=2)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +branch(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntValBranch(X2,Y2) + -> gecode_constraint_branch_16(Y0,Y1,Y2) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntValBranch(X2,Y2) + -> gecode_constraint_branch_12(Y0,Y1,Y2) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetValBranch(X2,Y2) + -> gecode_constraint_branch_17(Y0,Y1,Y2) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=2))))) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=1))). + +dom(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> gecode_constraint_dom_140(Y0,Y1,Y2) + ; (is_IntSet(X2,Y2) + -> gecode_constraint_dom_134(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))) + ; (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> gecode_constraint_dom_128(Y0,Y1,Y2) + ; (is_IntSet(X2,Y2) + -> gecode_constraint_dom_126(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=1))). + +linear(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_linear_208(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_linear_211(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))) + ; (is_IntVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_linear_212(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_linear_215(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_linear_184(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_linear_187(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))) + ; (is_IntVar(X3,Y3) + -> (is_BoolVar(X4,Y4) + -> gecode_constraint_linear_188(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_linear_191(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_linear_202(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_linear_206(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4))) + ; (is_BoolVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_linear_194(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_linear_198(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=2))))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=1))). + +nooverlap(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> gecode_constraint_nooverlap_240(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_nooverlap_243(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=1))). + +element(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetOpType(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_element_183(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_element_181(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntSetArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_element_179(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_element_177(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=3)))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=1))). + +rel(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_rel_290(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_rel_286(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_rel_298(Y0,Y1,Y2,Y3) + ; (is_BoolVarArgs(X3,Y3) + -> gecode_constraint_rel_294(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_rel_292(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_rel_297(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3))) + ; (is_SetOpType(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> gecode_constraint_rel_324(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> gecode_constraint_rel_322(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_rel_306(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_rel_308(Y0,Y1,Y2,Y3) + ; (is_IntVarArgs(X3,Y3) + -> gecode_constraint_rel_302(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_rel_305(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3))) + ; (is_IntVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_rel_312(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_rel_316(Y0,Y1,Y2,Y3) + ; (is_SetVar(X3,Y3) + -> gecode_constraint_rel_318(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))))) + ; (is_SetRelType(X2,Y2) + -> (is_SetVar(X3,Y3) + -> gecode_constraint_rel_319(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))) + ; (is_SetVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_rel_325(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))) + ; (is_SetRelType(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_rel_330(Y0,Y1,Y2,Y3) + ; (is_SetVar(X3,Y3) + -> gecode_constraint_rel_332(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))) + ; (is_BoolOpType(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_rel_278(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_rel_276(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=2))))))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=1))). + +min(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_min_233(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=1))). + +count(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> gecode_constraint_count_68(Y0,Y1,Y2) + ; (is_IntSetArgs(X2,Y2) + -> gecode_constraint_count_58(Y0,Y1,Y2) + ; throw(gecode_argument_error(count(X0,X1,X2),arg=3)))) + ; throw(gecode_argument_error(count(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(count(X0,X1,X2),arg=1))). + diff --git a/library/gecode/3.7.3/gecode_yap_cc_forward_auto_generated.icc b/library/gecode/3.7.3/gecode_yap_cc_forward_auto_generated.icc new file mode 100644 index 000000000..67781a39b --- /dev/null +++ b/library/gecode/3.7.3/gecode_yap_cc_forward_auto_generated.icc @@ -0,0 +1,31 @@ +// -*- c++ -*- +//============================================================================= +// Copyright (C) 2011 by Denys Duchier +// +// This program is free software: you can redistribute it and/or modify it +// under the terms of the GNU Lesser General Public License as published by the +// Free Software Foundation, either version 3 of the License, or (at your +// option) any later version. +// +// This program is distributed in the hope that it will be useful, but WITHOUT +// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +// more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . +//============================================================================= + +static IntRelType gecode_IntRelType_from_term(YAP_Term); +static BoolOpType gecode_BoolOpType_from_term(YAP_Term); +static IntConLevel gecode_IntConLevel_from_term(YAP_Term); +static TaskType gecode_TaskType_from_term(YAP_Term); +static ExtensionalPropKind gecode_ExtensionalPropKind_from_term(YAP_Term); +static IntVarBranch gecode_IntVarBranch_from_term(YAP_Term); +static IntValBranch gecode_IntValBranch_from_term(YAP_Term); +static IntAssign gecode_IntAssign_from_term(YAP_Term); +static SetRelType gecode_SetRelType_from_term(YAP_Term); +static SetOpType gecode_SetOpType_from_term(YAP_Term); +static SetVarBranch gecode_SetVarBranch_from_term(YAP_Term); +static SetValBranch gecode_SetValBranch_from_term(YAP_Term); +static SetAssign gecode_SetAssign_from_term(YAP_Term); diff --git a/library/gecode/3.7.3/gecode_yap_cc_impl_auto_generated.icc b/library/gecode/3.7.3/gecode_yap_cc_impl_auto_generated.icc new file mode 100644 index 000000000..8b41f068b --- /dev/null +++ b/library/gecode/3.7.3/gecode_yap_cc_impl_auto_generated.icc @@ -0,0 +1,4315 @@ +// -*- c++ -*- +//============================================================================= +// Copyright (C) 2011 by Denys Duchier +// +// This program is free software: you can redistribute it and/or modify it +// under the terms of the GNU Lesser General Public License as published by the +// Free Software Foundation, either version 3 of the License, or (at your +// option) any later version. +// +// This program is distributed in the hope that it will be useful, but WITHOUT +// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +// more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . +//============================================================================= + +static YAP_Term gecode_IRT_EQ; +static YAP_Term gecode_IRT_NQ; +static YAP_Term gecode_IRT_LQ; +static YAP_Term gecode_IRT_LE; +static YAP_Term gecode_IRT_GQ; +static YAP_Term gecode_IRT_GR; + +static IntRelType gecode_IntRelType_from_term(YAP_Term X) +{ + if (X==gecode_IRT_EQ) return IRT_EQ; + if (X==gecode_IRT_NQ) return IRT_NQ; + if (X==gecode_IRT_LQ) return IRT_LQ; + if (X==gecode_IRT_LE) return IRT_LE; + if (X==gecode_IRT_GQ) return IRT_GQ; + if (X==gecode_IRT_GR) return IRT_GR; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_BOT_AND; +static YAP_Term gecode_BOT_OR; +static YAP_Term gecode_BOT_IMP; +static YAP_Term gecode_BOT_EQV; +static YAP_Term gecode_BOT_XOR; + +static BoolOpType gecode_BoolOpType_from_term(YAP_Term X) +{ + if (X==gecode_BOT_AND) return BOT_AND; + if (X==gecode_BOT_OR) return BOT_OR; + if (X==gecode_BOT_IMP) return BOT_IMP; + if (X==gecode_BOT_EQV) return BOT_EQV; + if (X==gecode_BOT_XOR) return BOT_XOR; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_ICL_VAL; +static YAP_Term gecode_ICL_BND; +static YAP_Term gecode_ICL_DOM; +static YAP_Term gecode_ICL_DEF; + +static IntConLevel gecode_IntConLevel_from_term(YAP_Term X) +{ + if (X==gecode_ICL_VAL) return ICL_VAL; + if (X==gecode_ICL_BND) return ICL_BND; + if (X==gecode_ICL_DOM) return ICL_DOM; + if (X==gecode_ICL_DEF) return ICL_DEF; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_TT_FIXP; +static YAP_Term gecode_TT_FIXS; +static YAP_Term gecode_TT_FIXE; + +static TaskType gecode_TaskType_from_term(YAP_Term X) +{ + if (X==gecode_TT_FIXP) return TT_FIXP; + if (X==gecode_TT_FIXS) return TT_FIXS; + if (X==gecode_TT_FIXE) return TT_FIXE; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_EPK_DEF; +static YAP_Term gecode_EPK_SPEED; +static YAP_Term gecode_EPK_MEMORY; + +static ExtensionalPropKind gecode_ExtensionalPropKind_from_term(YAP_Term X) +{ + if (X==gecode_EPK_DEF) return EPK_DEF; + if (X==gecode_EPK_SPEED) return EPK_SPEED; + if (X==gecode_EPK_MEMORY) return EPK_MEMORY; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_INT_VAR_NONE; +static YAP_Term gecode_INT_VAR_RND; +static YAP_Term gecode_INT_VAR_DEGREE_MIN; +static YAP_Term gecode_INT_VAR_DEGREE_MAX; +static YAP_Term gecode_INT_VAR_AFC_MIN; +static YAP_Term gecode_INT_VAR_AFC_MAX; +static YAP_Term gecode_INT_VAR_MIN_MIN; +static YAP_Term gecode_INT_VAR_MIN_MAX; +static YAP_Term gecode_INT_VAR_MAX_MIN; +static YAP_Term gecode_INT_VAR_MAX_MAX; +static YAP_Term gecode_INT_VAR_SIZE_MIN; +static YAP_Term gecode_INT_VAR_SIZE_MAX; +static YAP_Term gecode_INT_VAR_SIZE_DEGREE_MIN; +static YAP_Term gecode_INT_VAR_SIZE_DEGREE_MAX; +static YAP_Term gecode_INT_VAR_SIZE_AFC_MIN; +static YAP_Term gecode_INT_VAR_SIZE_AFC_MAX; +static YAP_Term gecode_INT_VAR_REGRET_MIN_MIN; +static YAP_Term gecode_INT_VAR_REGRET_MIN_MAX; +static YAP_Term gecode_INT_VAR_REGRET_MAX_MIN; +static YAP_Term gecode_INT_VAR_REGRET_MAX_MAX; + +static IntVarBranch gecode_IntVarBranch_from_term(YAP_Term X) +{ + if (X==gecode_INT_VAR_NONE) return INT_VAR_NONE; + if (X==gecode_INT_VAR_RND) return INT_VAR_RND; + if (X==gecode_INT_VAR_DEGREE_MIN) return INT_VAR_DEGREE_MIN; + if (X==gecode_INT_VAR_DEGREE_MAX) return INT_VAR_DEGREE_MAX; + if (X==gecode_INT_VAR_AFC_MIN) return INT_VAR_AFC_MIN; + if (X==gecode_INT_VAR_AFC_MAX) return INT_VAR_AFC_MAX; + if (X==gecode_INT_VAR_MIN_MIN) return INT_VAR_MIN_MIN; + if (X==gecode_INT_VAR_MIN_MAX) return INT_VAR_MIN_MAX; + if (X==gecode_INT_VAR_MAX_MIN) return INT_VAR_MAX_MIN; + if (X==gecode_INT_VAR_MAX_MAX) return INT_VAR_MAX_MAX; + if (X==gecode_INT_VAR_SIZE_MIN) return INT_VAR_SIZE_MIN; + if (X==gecode_INT_VAR_SIZE_MAX) return INT_VAR_SIZE_MAX; + if (X==gecode_INT_VAR_SIZE_DEGREE_MIN) return INT_VAR_SIZE_DEGREE_MIN; + if (X==gecode_INT_VAR_SIZE_DEGREE_MAX) return INT_VAR_SIZE_DEGREE_MAX; + if (X==gecode_INT_VAR_SIZE_AFC_MIN) return INT_VAR_SIZE_AFC_MIN; + if (X==gecode_INT_VAR_SIZE_AFC_MAX) return INT_VAR_SIZE_AFC_MAX; + if (X==gecode_INT_VAR_REGRET_MIN_MIN) return INT_VAR_REGRET_MIN_MIN; + if (X==gecode_INT_VAR_REGRET_MIN_MAX) return INT_VAR_REGRET_MIN_MAX; + if (X==gecode_INT_VAR_REGRET_MAX_MIN) return INT_VAR_REGRET_MAX_MIN; + if (X==gecode_INT_VAR_REGRET_MAX_MAX) return INT_VAR_REGRET_MAX_MAX; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_INT_VAL_MIN; +static YAP_Term gecode_INT_VAL_MED; +static YAP_Term gecode_INT_VAL_MAX; +static YAP_Term gecode_INT_VAL_RND; +static YAP_Term gecode_INT_VAL_SPLIT_MIN; +static YAP_Term gecode_INT_VAL_SPLIT_MAX; +static YAP_Term gecode_INT_VAL_RANGE_MIN; +static YAP_Term gecode_INT_VAL_RANGE_MAX; +static YAP_Term gecode_INT_VALUES_MIN; +static YAP_Term gecode_INT_VALUES_MAX; + +static IntValBranch gecode_IntValBranch_from_term(YAP_Term X) +{ + if (X==gecode_INT_VAL_MIN) return INT_VAL_MIN; + if (X==gecode_INT_VAL_MED) return INT_VAL_MED; + if (X==gecode_INT_VAL_MAX) return INT_VAL_MAX; + if (X==gecode_INT_VAL_RND) return INT_VAL_RND; + if (X==gecode_INT_VAL_SPLIT_MIN) return INT_VAL_SPLIT_MIN; + if (X==gecode_INT_VAL_SPLIT_MAX) return INT_VAL_SPLIT_MAX; + if (X==gecode_INT_VAL_RANGE_MIN) return INT_VAL_RANGE_MIN; + if (X==gecode_INT_VAL_RANGE_MAX) return INT_VAL_RANGE_MAX; + if (X==gecode_INT_VALUES_MIN) return INT_VALUES_MIN; + if (X==gecode_INT_VALUES_MAX) return INT_VALUES_MAX; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_INT_ASSIGN_MIN; +static YAP_Term gecode_INT_ASSIGN_MED; +static YAP_Term gecode_INT_ASSIGN_MAX; +static YAP_Term gecode_INT_ASSIGN_RND; + +static IntAssign gecode_IntAssign_from_term(YAP_Term X) +{ + if (X==gecode_INT_ASSIGN_MIN) return INT_ASSIGN_MIN; + if (X==gecode_INT_ASSIGN_MED) return INT_ASSIGN_MED; + if (X==gecode_INT_ASSIGN_MAX) return INT_ASSIGN_MAX; + if (X==gecode_INT_ASSIGN_RND) return INT_ASSIGN_RND; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_SRT_EQ; +static YAP_Term gecode_SRT_NQ; +static YAP_Term gecode_SRT_SUB; +static YAP_Term gecode_SRT_SUP; +static YAP_Term gecode_SRT_DISJ; +static YAP_Term gecode_SRT_CMPL; +static YAP_Term gecode_SRT_LQ; +static YAP_Term gecode_SRT_LE; +static YAP_Term gecode_SRT_GQ; +static YAP_Term gecode_SRT_GR; + +static SetRelType gecode_SetRelType_from_term(YAP_Term X) +{ + if (X==gecode_SRT_EQ) return SRT_EQ; + if (X==gecode_SRT_NQ) return SRT_NQ; + if (X==gecode_SRT_SUB) return SRT_SUB; + if (X==gecode_SRT_SUP) return SRT_SUP; + if (X==gecode_SRT_DISJ) return SRT_DISJ; + if (X==gecode_SRT_CMPL) return SRT_CMPL; + if (X==gecode_SRT_LQ) return SRT_LQ; + if (X==gecode_SRT_LE) return SRT_LE; + if (X==gecode_SRT_GQ) return SRT_GQ; + if (X==gecode_SRT_GR) return SRT_GR; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_SOT_UNION; +static YAP_Term gecode_SOT_DUNION; +static YAP_Term gecode_SOT_INTER; +static YAP_Term gecode_SOT_MINUS; + +static SetOpType gecode_SetOpType_from_term(YAP_Term X) +{ + if (X==gecode_SOT_UNION) return SOT_UNION; + if (X==gecode_SOT_DUNION) return SOT_DUNION; + if (X==gecode_SOT_INTER) return SOT_INTER; + if (X==gecode_SOT_MINUS) return SOT_MINUS; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_SET_VAR_NONE; +static YAP_Term gecode_SET_VAR_RND; +static YAP_Term gecode_SET_VAR_DEGREE_MIN; +static YAP_Term gecode_SET_VAR_DEGREE_MAX; +static YAP_Term gecode_SET_VAR_AFC_MIN; +static YAP_Term gecode_SET_VAR_AFC_MAX; +static YAP_Term gecode_SET_VAR_MIN_MIN; +static YAP_Term gecode_SET_VAR_MIN_MAX; +static YAP_Term gecode_SET_VAR_MAX_MIN; +static YAP_Term gecode_SET_VAR_MAX_MAX; +static YAP_Term gecode_SET_VAR_SIZE_MIN; +static YAP_Term gecode_SET_VAR_SIZE_MAX; +static YAP_Term gecode_SET_VAR_SIZE_DEGREE_MIN; +static YAP_Term gecode_SET_VAR_SIZE_DEGREE_MAX; +static YAP_Term gecode_SET_VAR_SIZE_AFC_MIN; +static YAP_Term gecode_SET_VAR_SIZE_AFC_MAX; + +static SetVarBranch gecode_SetVarBranch_from_term(YAP_Term X) +{ + if (X==gecode_SET_VAR_NONE) return SET_VAR_NONE; + if (X==gecode_SET_VAR_RND) return SET_VAR_RND; + if (X==gecode_SET_VAR_DEGREE_MIN) return SET_VAR_DEGREE_MIN; + if (X==gecode_SET_VAR_DEGREE_MAX) return SET_VAR_DEGREE_MAX; + if (X==gecode_SET_VAR_AFC_MIN) return SET_VAR_AFC_MIN; + if (X==gecode_SET_VAR_AFC_MAX) return SET_VAR_AFC_MAX; + if (X==gecode_SET_VAR_MIN_MIN) return SET_VAR_MIN_MIN; + if (X==gecode_SET_VAR_MIN_MAX) return SET_VAR_MIN_MAX; + if (X==gecode_SET_VAR_MAX_MIN) return SET_VAR_MAX_MIN; + if (X==gecode_SET_VAR_MAX_MAX) return SET_VAR_MAX_MAX; + if (X==gecode_SET_VAR_SIZE_MIN) return SET_VAR_SIZE_MIN; + if (X==gecode_SET_VAR_SIZE_MAX) return SET_VAR_SIZE_MAX; + if (X==gecode_SET_VAR_SIZE_DEGREE_MIN) return SET_VAR_SIZE_DEGREE_MIN; + if (X==gecode_SET_VAR_SIZE_DEGREE_MAX) return SET_VAR_SIZE_DEGREE_MAX; + if (X==gecode_SET_VAR_SIZE_AFC_MIN) return SET_VAR_SIZE_AFC_MIN; + if (X==gecode_SET_VAR_SIZE_AFC_MAX) return SET_VAR_SIZE_AFC_MAX; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_SET_VAL_MIN_INC; +static YAP_Term gecode_SET_VAL_MIN_EXC; +static YAP_Term gecode_SET_VAL_MED_INC; +static YAP_Term gecode_SET_VAL_MED_EXC; +static YAP_Term gecode_SET_VAL_MAX_INC; +static YAP_Term gecode_SET_VAL_MAX_EXC; +static YAP_Term gecode_SET_VAL_RND_INC; +static YAP_Term gecode_SET_VAL_RND_EXC; + +static SetValBranch gecode_SetValBranch_from_term(YAP_Term X) +{ + if (X==gecode_SET_VAL_MIN_INC) return SET_VAL_MIN_INC; + if (X==gecode_SET_VAL_MIN_EXC) return SET_VAL_MIN_EXC; + if (X==gecode_SET_VAL_MED_INC) return SET_VAL_MED_INC; + if (X==gecode_SET_VAL_MED_EXC) return SET_VAL_MED_EXC; + if (X==gecode_SET_VAL_MAX_INC) return SET_VAL_MAX_INC; + if (X==gecode_SET_VAL_MAX_EXC) return SET_VAL_MAX_EXC; + if (X==gecode_SET_VAL_RND_INC) return SET_VAL_RND_INC; + if (X==gecode_SET_VAL_RND_EXC) return SET_VAL_RND_EXC; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_SET_ASSIGN_MIN_INC; +static YAP_Term gecode_SET_ASSIGN_MIN_EXC; +static YAP_Term gecode_SET_ASSIGN_MED_INC; +static YAP_Term gecode_SET_ASSIGN_MED_EXC; +static YAP_Term gecode_SET_ASSIGN_MAX_INC; +static YAP_Term gecode_SET_ASSIGN_MAX_EXC; +static YAP_Term gecode_SET_ASSIGN_RND_INC; +static YAP_Term gecode_SET_ASSIGN_RND_EXC; + +static SetAssign gecode_SetAssign_from_term(YAP_Term X) +{ + if (X==gecode_SET_ASSIGN_MIN_INC) return SET_ASSIGN_MIN_INC; + if (X==gecode_SET_ASSIGN_MIN_EXC) return SET_ASSIGN_MIN_EXC; + if (X==gecode_SET_ASSIGN_MED_INC) return SET_ASSIGN_MED_INC; + if (X==gecode_SET_ASSIGN_MED_EXC) return SET_ASSIGN_MED_EXC; + if (X==gecode_SET_ASSIGN_MAX_INC) return SET_ASSIGN_MAX_INC; + if (X==gecode_SET_ASSIGN_MAX_EXC) return SET_ASSIGN_MAX_EXC; + if (X==gecode_SET_ASSIGN_RND_INC) return SET_ASSIGN_RND_INC; + if (X==gecode_SET_ASSIGN_RND_EXC) return SET_ASSIGN_RND_EXC; + cerr << "this should never happen" << endl; exit(1); +} + +static int gecode_constraint_unary_357(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + BoolVarArgs X5 = gecode_BoolVarArgs_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + unary(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_unary_353(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + BoolVarArgs X5 = gecode_BoolVarArgs_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + unary(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_nvalues_255(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + nvalues(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_nvalues_257(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + nvalues(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_nvalues_251(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + nvalues(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_nvalues_253(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + nvalues(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_max_218(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + max(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_max_217(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + max(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_max_221(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + max(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_139(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + dom(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_dom_149(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + dom(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_convex_51(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + convex(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_nooverlap_242(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + nooverlap(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_assign_4(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_assign_3(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_assign_5(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_assign_7(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_assign_6(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetAssign X3 = gecode_SetAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_assign_8(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetAssign X3 = gecode_SetAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_element_158(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_162(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_152(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_150(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_157(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntSetArgs X2 = gecode_IntSetArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_165(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_168(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_174(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_166(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_sequence_338(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + sequence(*space,X2); + return TRUE; +} + +static int gecode_constraint_notMax_248(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + notMax(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_unary_350(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + unary(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_circuit_45(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + circuit(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_circuit_36(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + circuit(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_138(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_dom_143(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_dom_137(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_dom_133(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_dom_131(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_dom_148(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_dom_147(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_dom_145(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_channel_32(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + channel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_channel_27(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + channel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_channel_23(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + channel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_channel_21(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + channel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_nooverlap_244(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + BoolVarArgs X8 = gecode_BoolVarArgs_from_term(space,YAP_ARG8); + nooverlap(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_nooverlap_247(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + nooverlap(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_element_160(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_element_154(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + BoolVar X7 = gecode_BoolVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_element_156(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntSetArgs X2 = gecode_IntSetArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + SetVar X7 = gecode_SetVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_element_164(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + SetVar X7 = gecode_SetVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_element_172(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_element_170(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + BoolVar X7 = gecode_BoolVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_max_216(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + max(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_max_220(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + max(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_unshare_362(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + unshare(*space,X2); + return TRUE; +} + +static int gecode_constraint_unshare_360(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + unshare(*space,X2); + return TRUE; +} + +static int gecode_constraint_path_268(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + path(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_path_267(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + path(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_mult_238(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + mult(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_clause_49(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + clause(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_clause_47(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + clause(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_precede_273(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + precede(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_distinct_120(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + distinct(*space,X2); + return TRUE; +} + +static int gecode_constraint_member_226(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + member(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_member_229(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + member(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_member_222(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + member(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_member_225(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + member(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_mod_237(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + mod(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_cardinality_18(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + cardinality(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_atmostOne_9(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + atmostOne(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_channelSorted_33(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + channelSorted(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_linear_210(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_linear_214(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_linear_186(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_linear_190(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_circuit_42(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + circuit(*space,X2); + return TRUE; +} + +static int gecode_constraint_rel_288(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_291(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_284(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_287(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_282(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolOpType X3 = gecode_BoolOpType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_280(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolOpType X3 = gecode_BoolOpType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_299(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_295(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_293(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_323(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_321(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_307(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_309(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_303(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_310(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_313(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_314(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_317(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_320(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_331(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_333(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_279(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_277(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_min_232(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + min(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_min_231(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + min(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_min_235(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + min(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_cardinality_19(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + cardinality(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_count_69(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_count_66(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_count_60(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_count_59(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_count_56(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_sqrt_346(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + sqrt(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_cumulatives_117(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_cumulatives_115(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_cumulatives_113(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_cumulatives_111(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_cumulatives_109(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_cumulatives_107(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_cumulatives_105(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_cumulatives_103(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_nvalues_254(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + nvalues(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_nvalues_256(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + nvalues(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_nvalues_250(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + nvalues(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_nvalues_252(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + nvalues(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_binpacking_10(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + binpacking(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_linear_201(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + linear(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_linear_205(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + linear(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_linear_193(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + linear(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_linear_197(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + linear(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_abs_2(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + abs(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_convex_50(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + convex(*space,X2); + return TRUE; +} + +static int gecode_constraint_div_122(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + div(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_311(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_315(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_300(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntSet X2 = gecode_IntSet_from_term(YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_301(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntSet X2 = gecode_IntSet_from_term(YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + SetVar X6 = gecode_SetVar_from_term(space,YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_289(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_285(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_283(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolOpType X3 = gecode_BoolOpType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_281(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolOpType X3 = gecode_BoolOpType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_326(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_327(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + SetVar X6 = gecode_SetVar_from_term(space,YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_328(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_329(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + SetVar X6 = gecode_SetVar_from_term(space,YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_weights_364(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + weights(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_max_219(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + max(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_path_263(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + IntVar X8 = gecode_IntVar_from_term(space,YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + path(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_unary_358(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + unary(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_unary_354(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + unary(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_unary_348(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + unary(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_unary_351(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + unary(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_sorted_341(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + sorted(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_circuit_40(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + circuit(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_circuit_37(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + circuit(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_circuit_34(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + circuit(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_dom_142(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_136(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_141(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_132(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_135(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_130(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_129(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_127(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_146(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_dom_144(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_abs_1(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + abs(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_channel_29(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + channel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_channel_24(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + channel(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_rel_304(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + rel(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_rel_296(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + rel(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_path_266(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + path(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_branch_14(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_branch_13(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_branch_15(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarBranch X3 = gecode_SetVarBranch_from_term(YAP_ARG3); + SetValBranch X4 = gecode_SetValBranch_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_mult_239(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + mult(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_circuit_41(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + circuit(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_circuit_38(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + circuit(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_circuit_35(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + circuit(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_clause_48(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + clause(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_clause_46(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + clause(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_precede_275(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + precede(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_precede_272(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + precede(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_precede_271(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + precede(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_channel_30(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + channel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_cumulative_86(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_89(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_82(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_85(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_79(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_98(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_101(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_94(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_97(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_cumulative_91(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_distinct_121(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntConLevel X3 = gecode_IntConLevel_from_term(YAP_ARG3); + distinct(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_distinct_118(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + distinct(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_member_227(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + member(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_member_223(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + member(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_mod_236(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + mod(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_sqr_344(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + sqr(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_sequence_337(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + sequence(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_sequence_335(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + sequence(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_path_264(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + path(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_path_261(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + path(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_path_258(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + path(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_divmod_125(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + divmod(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_sorted_342(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + sorted(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_circuit_44(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + circuit(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_circuit_43(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntConLevel X3 = gecode_IntConLevel_from_term(YAP_ARG3); + circuit(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_channel_31(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_channel_28(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_channel_26(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_channel_22(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_channel_25(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_channel_20(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_count_52(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_54(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_70(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_72(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_62(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_64(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_61(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_57(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_67(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_74(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_76(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_cumulatives_116(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulatives_114(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulatives_112(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulatives_110(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulatives_108(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulatives_106(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulatives_104(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulatives_102(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_binpacking_11(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + binpacking(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_209(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_213(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_185(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_189(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_200(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_203(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_204(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_207(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_192(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_195(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_196(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + BoolVar X6 = gecode_BoolVar_from_term(space,YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_linear_199(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_nooverlap_246(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + nooverlap(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_nooverlap_241(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + nooverlap(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_div_123(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + div(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_sqr_345(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + sqr(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_path_265(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + path(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_path_262(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + IntVar X8 = gecode_IntVar_from_term(space,YAP_ARG8); + path(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_path_259(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + path(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_unary_356(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + BoolVarArgs X5 = gecode_BoolVarArgs_from_term(space,YAP_ARG5); + unary(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_unary_359(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + unary(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_unary_352(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + BoolVarArgs X5 = gecode_BoolVarArgs_from_term(space,YAP_ARG5); + unary(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_unary_355(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + unary(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_unary_349(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + unary(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_sorted_340(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + sorted(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_sorted_343(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + sorted(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_element_161(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + element(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_element_155(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + BoolVar X7 = gecode_BoolVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + element(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_element_173(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + element(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_element_171(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + BoolVar X7 = gecode_BoolVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + element(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_element_159(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_163(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_153(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_151(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_182(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_180(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_178(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_176(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_169(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_175(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_element_167(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_sequence_339(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + sequence(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_circuit_39(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + circuit(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static int gecode_constraint_precede_274(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + precede(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_precede_270(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + precede(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_cumulative_88(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_cumulative_84(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_cumulative_78(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_cumulative_81(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_cumulative_100(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_cumulative_96(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_cumulative_90(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_cumulative_93(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_distinct_119(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + distinct(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_min_230(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + min(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_min_234(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + min(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_sqrt_347(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + sqrt(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_sequence_336(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + sequence(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_sequence_334(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + sequence(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_unshare_363(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntConLevel X3 = gecode_IntConLevel_from_term(YAP_ARG3); + unshare(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_unshare_361(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntConLevel X3 = gecode_IntConLevel_from_term(YAP_ARG3); + unshare(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_path_269(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + path(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_path_260(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + path(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_divmod_124(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + divmod(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_nooverlap_245(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + BoolVarArgs X8 = gecode_BoolVarArgs_from_term(space,YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + nooverlap(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static int gecode_constraint_cumulative_80(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + cumulative(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_cumulative_92(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + cumulative(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_member_228(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + member(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_member_224(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + member(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_count_71(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_count_73(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_count_75(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_count_77(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_count_63(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_count_65(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_count_53(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_count_55(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_notMin_249(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + notMin(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_cumulative_87(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + cumulative(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulative_83(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + cumulative(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulative_99(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + cumulative(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_cumulative_95(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + cumulative(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static int gecode_constraint_branch_16(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntValBranch X3 = gecode_IntValBranch_from_term(YAP_ARG3); + branch(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_branch_12(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntValBranch X3 = gecode_IntValBranch_from_term(YAP_ARG3); + branch(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_branch_17(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetValBranch X3 = gecode_SetValBranch_from_term(YAP_ARG3); + branch(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_dom_140(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_dom_134(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_dom_128(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_dom_126(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_linear_208(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_211(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_212(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_215(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_184(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_187(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_188(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_191(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_202(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_206(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_194(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_linear_198(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_nooverlap_240(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + nooverlap(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_nooverlap_243(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + nooverlap(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_element_183(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + element(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_element_181(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + element(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_element_179(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + element(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_element_177(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + element(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static int gecode_constraint_rel_290(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_286(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_298(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_294(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_292(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_297(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_324(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_322(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_306(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_308(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_302(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_305(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_312(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_316(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_318(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_319(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_325(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_330(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_332(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_278(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_rel_276(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static int gecode_constraint_min_233(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + min(*space,X2,X3,X4,X5); + return TRUE; +} + +static int gecode_constraint_count_68(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + count(*space,X2,X3); + return TRUE; +} + +static int gecode_constraint_count_58(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + count(*space,X2,X3); + return TRUE; +} + diff --git a/library/gecode/3.7.3/gecode_yap_cc_init_auto_generated.icc b/library/gecode/3.7.3/gecode_yap_cc_init_auto_generated.icc new file mode 100644 index 000000000..cb05df765 --- /dev/null +++ b/library/gecode/3.7.3/gecode_yap_cc_init_auto_generated.icc @@ -0,0 +1,698 @@ +// -*- c++ -*- +//============================================================================= +// Copyright (C) 2011 by Denys Duchier +// +// This program is free software: you can redistribute it and/or modify it +// under the terms of the GNU Lesser General Public License as published by the +// Free Software Foundation, either version 3 of the License, or (at your +// option) any later version. +// +// This program is distributed in the hope that it will be useful, but WITHOUT +// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +// more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . +//============================================================================= + +{ YAP_Atom X= YAP_LookupAtom("IRT_EQ"); + gecode_IRT_EQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_NQ"); + gecode_IRT_NQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_LQ"); + gecode_IRT_LQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_LE"); + gecode_IRT_LE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_GQ"); + gecode_IRT_GQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_GR"); + gecode_IRT_GR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("BOT_AND"); + gecode_BOT_AND = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("BOT_OR"); + gecode_BOT_OR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("BOT_IMP"); + gecode_BOT_IMP = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("BOT_EQV"); + gecode_BOT_EQV = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("BOT_XOR"); + gecode_BOT_XOR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("ICL_VAL"); + gecode_ICL_VAL = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("ICL_BND"); + gecode_ICL_BND = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("ICL_DOM"); + gecode_ICL_DOM = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("ICL_DEF"); + gecode_ICL_DEF = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("TT_FIXP"); + gecode_TT_FIXP = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("TT_FIXS"); + gecode_TT_FIXS = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("TT_FIXE"); + gecode_TT_FIXE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("EPK_DEF"); + gecode_EPK_DEF = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("EPK_SPEED"); + gecode_EPK_SPEED = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("EPK_MEMORY"); + gecode_EPK_MEMORY = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_NONE"); + gecode_INT_VAR_NONE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_RND"); + gecode_INT_VAR_RND = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_MIN"); + gecode_INT_VAR_DEGREE_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_MAX"); + gecode_INT_VAR_DEGREE_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_AFC_MIN"); + gecode_INT_VAR_AFC_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_AFC_MAX"); + gecode_INT_VAR_AFC_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_MIN_MIN"); + gecode_INT_VAR_MIN_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_MIN_MAX"); + gecode_INT_VAR_MIN_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_MAX_MIN"); + gecode_INT_VAR_MAX_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_MAX_MAX"); + gecode_INT_VAR_MAX_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_MIN"); + gecode_INT_VAR_SIZE_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_MAX"); + gecode_INT_VAR_SIZE_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_DEGREE_MIN"); + gecode_INT_VAR_SIZE_DEGREE_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_DEGREE_MAX"); + gecode_INT_VAR_SIZE_DEGREE_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_AFC_MIN"); + gecode_INT_VAR_SIZE_AFC_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_AFC_MAX"); + gecode_INT_VAR_SIZE_AFC_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MIN_MIN"); + gecode_INT_VAR_REGRET_MIN_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MIN_MAX"); + gecode_INT_VAR_REGRET_MIN_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MAX_MIN"); + gecode_INT_VAR_REGRET_MAX_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MAX_MAX"); + gecode_INT_VAR_REGRET_MAX_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("INT_VAL_MIN"); + gecode_INT_VAL_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAL_MED"); + gecode_INT_VAL_MED = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAL_MAX"); + gecode_INT_VAL_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAL_RND"); + gecode_INT_VAL_RND = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAL_SPLIT_MIN"); + gecode_INT_VAL_SPLIT_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAL_SPLIT_MAX"); + gecode_INT_VAL_SPLIT_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAL_RANGE_MIN"); + gecode_INT_VAL_RANGE_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VAL_RANGE_MAX"); + gecode_INT_VAL_RANGE_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VALUES_MIN"); + gecode_INT_VALUES_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_VALUES_MAX"); + gecode_INT_VALUES_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("INT_ASSIGN_MIN"); + gecode_INT_ASSIGN_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_ASSIGN_MED"); + gecode_INT_ASSIGN_MED = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_ASSIGN_MAX"); + gecode_INT_ASSIGN_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("INT_ASSIGN_RND"); + gecode_INT_ASSIGN_RND = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("SRT_EQ"); + gecode_SRT_EQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_NQ"); + gecode_SRT_NQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_SUB"); + gecode_SRT_SUB = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_SUP"); + gecode_SRT_SUP = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_DISJ"); + gecode_SRT_DISJ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_CMPL"); + gecode_SRT_CMPL = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_LQ"); + gecode_SRT_LQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_LE"); + gecode_SRT_LE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_GQ"); + gecode_SRT_GQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_GR"); + gecode_SRT_GR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("SOT_UNION"); + gecode_SOT_UNION = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SOT_DUNION"); + gecode_SOT_DUNION = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SOT_INTER"); + gecode_SOT_INTER = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SOT_MINUS"); + gecode_SOT_MINUS = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_NONE"); + gecode_SET_VAR_NONE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_RND"); + gecode_SET_VAR_RND = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_MIN"); + gecode_SET_VAR_DEGREE_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_MAX"); + gecode_SET_VAR_DEGREE_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_AFC_MIN"); + gecode_SET_VAR_AFC_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_AFC_MAX"); + gecode_SET_VAR_AFC_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_MIN_MIN"); + gecode_SET_VAR_MIN_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_MIN_MAX"); + gecode_SET_VAR_MIN_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_MAX_MIN"); + gecode_SET_VAR_MAX_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_MAX_MAX"); + gecode_SET_VAR_MAX_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_MIN"); + gecode_SET_VAR_SIZE_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_MAX"); + gecode_SET_VAR_SIZE_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_DEGREE_MIN"); + gecode_SET_VAR_SIZE_DEGREE_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_DEGREE_MAX"); + gecode_SET_VAR_SIZE_DEGREE_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_AFC_MIN"); + gecode_SET_VAR_SIZE_AFC_MIN = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_AFC_MAX"); + gecode_SET_VAR_SIZE_AFC_MAX = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("SET_VAL_MIN_INC"); + gecode_SET_VAL_MIN_INC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAL_MIN_EXC"); + gecode_SET_VAL_MIN_EXC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAL_MED_INC"); + gecode_SET_VAL_MED_INC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAL_MED_EXC"); + gecode_SET_VAL_MED_EXC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAL_MAX_INC"); + gecode_SET_VAL_MAX_INC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAL_MAX_EXC"); + gecode_SET_VAL_MAX_EXC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAL_RND_INC"); + gecode_SET_VAL_RND_INC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_VAL_RND_EXC"); + gecode_SET_VAL_RND_EXC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("SET_ASSIGN_MIN_INC"); + gecode_SET_ASSIGN_MIN_INC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_ASSIGN_MIN_EXC"); + gecode_SET_ASSIGN_MIN_EXC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_ASSIGN_MED_INC"); + gecode_SET_ASSIGN_MED_INC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_ASSIGN_MED_EXC"); + gecode_SET_ASSIGN_MED_EXC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_ASSIGN_MAX_INC"); + gecode_SET_ASSIGN_MAX_INC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_ASSIGN_MAX_EXC"); + gecode_SET_ASSIGN_MAX_EXC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_ASSIGN_RND_INC"); + gecode_SET_ASSIGN_RND_INC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SET_ASSIGN_RND_EXC"); + gecode_SET_ASSIGN_RND_EXC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +YAP_UserCPredicate("gecode_constraint_unary_357", gecode_constraint_unary_357, 6); +YAP_UserCPredicate("gecode_constraint_unary_353", gecode_constraint_unary_353, 6); +YAP_UserCPredicate("gecode_constraint_nvalues_255", gecode_constraint_nvalues_255, 5); +YAP_UserCPredicate("gecode_constraint_nvalues_257", gecode_constraint_nvalues_257, 5); +YAP_UserCPredicate("gecode_constraint_nvalues_251", gecode_constraint_nvalues_251, 5); +YAP_UserCPredicate("gecode_constraint_nvalues_253", gecode_constraint_nvalues_253, 5); +YAP_UserCPredicate("gecode_constraint_max_218", gecode_constraint_max_218, 4); +YAP_UserCPredicate("gecode_constraint_max_217", gecode_constraint_max_217, 4); +YAP_UserCPredicate("gecode_constraint_max_221", gecode_constraint_max_221, 4); +YAP_UserCPredicate("gecode_constraint_dom_139", gecode_constraint_dom_139, 6); +YAP_UserCPredicate("gecode_constraint_dom_149", gecode_constraint_dom_149, 6); +YAP_UserCPredicate("gecode_constraint_convex_51", gecode_constraint_convex_51, 3); +YAP_UserCPredicate("gecode_constraint_nooverlap_242", gecode_constraint_nooverlap_242, 5); +YAP_UserCPredicate("gecode_constraint_assign_4", gecode_constraint_assign_4, 3); +YAP_UserCPredicate("gecode_constraint_assign_3", gecode_constraint_assign_3, 3); +YAP_UserCPredicate("gecode_constraint_assign_5", gecode_constraint_assign_5, 3); +YAP_UserCPredicate("gecode_constraint_assign_7", gecode_constraint_assign_7, 3); +YAP_UserCPredicate("gecode_constraint_assign_6", gecode_constraint_assign_6, 3); +YAP_UserCPredicate("gecode_constraint_assign_8", gecode_constraint_assign_8, 3); +YAP_UserCPredicate("gecode_constraint_element_158", gecode_constraint_element_158, 4); +YAP_UserCPredicate("gecode_constraint_element_162", gecode_constraint_element_162, 4); +YAP_UserCPredicate("gecode_constraint_element_152", gecode_constraint_element_152, 4); +YAP_UserCPredicate("gecode_constraint_element_150", gecode_constraint_element_150, 4); +YAP_UserCPredicate("gecode_constraint_element_157", gecode_constraint_element_157, 4); +YAP_UserCPredicate("gecode_constraint_element_165", gecode_constraint_element_165, 4); +YAP_UserCPredicate("gecode_constraint_element_168", gecode_constraint_element_168, 4); +YAP_UserCPredicate("gecode_constraint_element_174", gecode_constraint_element_174, 4); +YAP_UserCPredicate("gecode_constraint_element_166", gecode_constraint_element_166, 4); +YAP_UserCPredicate("gecode_constraint_sequence_338", gecode_constraint_sequence_338, 2); +YAP_UserCPredicate("gecode_constraint_notMax_248", gecode_constraint_notMax_248, 3); +YAP_UserCPredicate("gecode_constraint_unary_350", gecode_constraint_unary_350, 3); +YAP_UserCPredicate("gecode_constraint_circuit_45", gecode_constraint_circuit_45, 4); +YAP_UserCPredicate("gecode_constraint_circuit_36", gecode_constraint_circuit_36, 4); +YAP_UserCPredicate("gecode_constraint_dom_138", gecode_constraint_dom_138, 5); +YAP_UserCPredicate("gecode_constraint_dom_143", gecode_constraint_dom_143, 5); +YAP_UserCPredicate("gecode_constraint_dom_137", gecode_constraint_dom_137, 5); +YAP_UserCPredicate("gecode_constraint_dom_133", gecode_constraint_dom_133, 5); +YAP_UserCPredicate("gecode_constraint_dom_131", gecode_constraint_dom_131, 5); +YAP_UserCPredicate("gecode_constraint_dom_148", gecode_constraint_dom_148, 5); +YAP_UserCPredicate("gecode_constraint_dom_147", gecode_constraint_dom_147, 5); +YAP_UserCPredicate("gecode_constraint_dom_145", gecode_constraint_dom_145, 5); +YAP_UserCPredicate("gecode_constraint_channel_32", gecode_constraint_channel_32, 4); +YAP_UserCPredicate("gecode_constraint_channel_27", gecode_constraint_channel_27, 4); +YAP_UserCPredicate("gecode_constraint_channel_23", gecode_constraint_channel_23, 4); +YAP_UserCPredicate("gecode_constraint_channel_21", gecode_constraint_channel_21, 4); +YAP_UserCPredicate("gecode_constraint_nooverlap_244", gecode_constraint_nooverlap_244, 8); +YAP_UserCPredicate("gecode_constraint_nooverlap_247", gecode_constraint_nooverlap_247, 8); +YAP_UserCPredicate("gecode_constraint_element_160", gecode_constraint_element_160, 7); +YAP_UserCPredicate("gecode_constraint_element_154", gecode_constraint_element_154, 7); +YAP_UserCPredicate("gecode_constraint_element_156", gecode_constraint_element_156, 7); +YAP_UserCPredicate("gecode_constraint_element_164", gecode_constraint_element_164, 7); +YAP_UserCPredicate("gecode_constraint_element_172", gecode_constraint_element_172, 7); +YAP_UserCPredicate("gecode_constraint_element_170", gecode_constraint_element_170, 7); +YAP_UserCPredicate("gecode_constraint_max_216", gecode_constraint_max_216, 3); +YAP_UserCPredicate("gecode_constraint_max_220", gecode_constraint_max_220, 3); +YAP_UserCPredicate("gecode_constraint_unshare_362", gecode_constraint_unshare_362, 2); +YAP_UserCPredicate("gecode_constraint_unshare_360", gecode_constraint_unshare_360, 2); +YAP_UserCPredicate("gecode_constraint_path_268", gecode_constraint_path_268, 5); +YAP_UserCPredicate("gecode_constraint_path_267", gecode_constraint_path_267, 5); +YAP_UserCPredicate("gecode_constraint_mult_238", gecode_constraint_mult_238, 4); +YAP_UserCPredicate("gecode_constraint_clause_49", gecode_constraint_clause_49, 6); +YAP_UserCPredicate("gecode_constraint_clause_47", gecode_constraint_clause_47, 6); +YAP_UserCPredicate("gecode_constraint_precede_273", gecode_constraint_precede_273, 5); +YAP_UserCPredicate("gecode_constraint_distinct_120", gecode_constraint_distinct_120, 2); +YAP_UserCPredicate("gecode_constraint_member_226", gecode_constraint_member_226, 4); +YAP_UserCPredicate("gecode_constraint_member_229", gecode_constraint_member_229, 4); +YAP_UserCPredicate("gecode_constraint_member_222", gecode_constraint_member_222, 4); +YAP_UserCPredicate("gecode_constraint_member_225", gecode_constraint_member_225, 4); +YAP_UserCPredicate("gecode_constraint_mod_237", gecode_constraint_mod_237, 5); +YAP_UserCPredicate("gecode_constraint_cardinality_18", gecode_constraint_cardinality_18, 3); +YAP_UserCPredicate("gecode_constraint_atmostOne_9", gecode_constraint_atmostOne_9, 3); +YAP_UserCPredicate("gecode_constraint_channelSorted_33", gecode_constraint_channelSorted_33, 3); +YAP_UserCPredicate("gecode_constraint_linear_210", gecode_constraint_linear_210, 4); +YAP_UserCPredicate("gecode_constraint_linear_214", gecode_constraint_linear_214, 4); +YAP_UserCPredicate("gecode_constraint_linear_186", gecode_constraint_linear_186, 4); +YAP_UserCPredicate("gecode_constraint_linear_190", gecode_constraint_linear_190, 4); +YAP_UserCPredicate("gecode_constraint_circuit_42", gecode_constraint_circuit_42, 2); +YAP_UserCPredicate("gecode_constraint_rel_288", gecode_constraint_rel_288, 5); +YAP_UserCPredicate("gecode_constraint_rel_291", gecode_constraint_rel_291, 5); +YAP_UserCPredicate("gecode_constraint_rel_284", gecode_constraint_rel_284, 5); +YAP_UserCPredicate("gecode_constraint_rel_287", gecode_constraint_rel_287, 5); +YAP_UserCPredicate("gecode_constraint_rel_282", gecode_constraint_rel_282, 5); +YAP_UserCPredicate("gecode_constraint_rel_280", gecode_constraint_rel_280, 5); +YAP_UserCPredicate("gecode_constraint_rel_299", gecode_constraint_rel_299, 5); +YAP_UserCPredicate("gecode_constraint_rel_295", gecode_constraint_rel_295, 5); +YAP_UserCPredicate("gecode_constraint_rel_293", gecode_constraint_rel_293, 5); +YAP_UserCPredicate("gecode_constraint_rel_323", gecode_constraint_rel_323, 5); +YAP_UserCPredicate("gecode_constraint_rel_321", gecode_constraint_rel_321, 5); +YAP_UserCPredicate("gecode_constraint_rel_307", gecode_constraint_rel_307, 5); +YAP_UserCPredicate("gecode_constraint_rel_309", gecode_constraint_rel_309, 5); +YAP_UserCPredicate("gecode_constraint_rel_303", gecode_constraint_rel_303, 5); +YAP_UserCPredicate("gecode_constraint_rel_310", gecode_constraint_rel_310, 5); +YAP_UserCPredicate("gecode_constraint_rel_313", gecode_constraint_rel_313, 5); +YAP_UserCPredicate("gecode_constraint_rel_314", gecode_constraint_rel_314, 5); +YAP_UserCPredicate("gecode_constraint_rel_317", gecode_constraint_rel_317, 5); +YAP_UserCPredicate("gecode_constraint_rel_320", gecode_constraint_rel_320, 5); +YAP_UserCPredicate("gecode_constraint_rel_331", gecode_constraint_rel_331, 5); +YAP_UserCPredicate("gecode_constraint_rel_333", gecode_constraint_rel_333, 5); +YAP_UserCPredicate("gecode_constraint_rel_279", gecode_constraint_rel_279, 5); +YAP_UserCPredicate("gecode_constraint_rel_277", gecode_constraint_rel_277, 5); +YAP_UserCPredicate("gecode_constraint_min_232", gecode_constraint_min_232, 4); +YAP_UserCPredicate("gecode_constraint_min_231", gecode_constraint_min_231, 4); +YAP_UserCPredicate("gecode_constraint_min_235", gecode_constraint_min_235, 4); +YAP_UserCPredicate("gecode_constraint_cardinality_19", gecode_constraint_cardinality_19, 4); +YAP_UserCPredicate("gecode_constraint_count_69", gecode_constraint_count_69, 4); +YAP_UserCPredicate("gecode_constraint_count_66", gecode_constraint_count_66, 4); +YAP_UserCPredicate("gecode_constraint_count_60", gecode_constraint_count_60, 4); +YAP_UserCPredicate("gecode_constraint_count_59", gecode_constraint_count_59, 4); +YAP_UserCPredicate("gecode_constraint_count_56", gecode_constraint_count_56, 4); +YAP_UserCPredicate("gecode_constraint_sqrt_346", gecode_constraint_sqrt_346, 3); +YAP_UserCPredicate("gecode_constraint_cumulatives_117", gecode_constraint_cumulatives_117, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_115", gecode_constraint_cumulatives_115, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_113", gecode_constraint_cumulatives_113, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_111", gecode_constraint_cumulatives_111, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_109", gecode_constraint_cumulatives_109, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_107", gecode_constraint_cumulatives_107, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_105", gecode_constraint_cumulatives_105, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_103", gecode_constraint_cumulatives_103, 9); +YAP_UserCPredicate("gecode_constraint_nvalues_254", gecode_constraint_nvalues_254, 4); +YAP_UserCPredicate("gecode_constraint_nvalues_256", gecode_constraint_nvalues_256, 4); +YAP_UserCPredicate("gecode_constraint_nvalues_250", gecode_constraint_nvalues_250, 4); +YAP_UserCPredicate("gecode_constraint_nvalues_252", gecode_constraint_nvalues_252, 4); +YAP_UserCPredicate("gecode_constraint_binpacking_10", gecode_constraint_binpacking_10, 4); +YAP_UserCPredicate("gecode_constraint_linear_201", gecode_constraint_linear_201, 7); +YAP_UserCPredicate("gecode_constraint_linear_205", gecode_constraint_linear_205, 7); +YAP_UserCPredicate("gecode_constraint_linear_193", gecode_constraint_linear_193, 7); +YAP_UserCPredicate("gecode_constraint_linear_197", gecode_constraint_linear_197, 7); +YAP_UserCPredicate("gecode_constraint_abs_2", gecode_constraint_abs_2, 4); +YAP_UserCPredicate("gecode_constraint_convex_50", gecode_constraint_convex_50, 2); +YAP_UserCPredicate("gecode_constraint_div_122", gecode_constraint_div_122, 4); +YAP_UserCPredicate("gecode_constraint_rel_311", gecode_constraint_rel_311, 6); +YAP_UserCPredicate("gecode_constraint_rel_315", gecode_constraint_rel_315, 6); +YAP_UserCPredicate("gecode_constraint_rel_300", gecode_constraint_rel_300, 6); +YAP_UserCPredicate("gecode_constraint_rel_301", gecode_constraint_rel_301, 6); +YAP_UserCPredicate("gecode_constraint_rel_289", gecode_constraint_rel_289, 6); +YAP_UserCPredicate("gecode_constraint_rel_285", gecode_constraint_rel_285, 6); +YAP_UserCPredicate("gecode_constraint_rel_283", gecode_constraint_rel_283, 6); +YAP_UserCPredicate("gecode_constraint_rel_281", gecode_constraint_rel_281, 6); +YAP_UserCPredicate("gecode_constraint_rel_326", gecode_constraint_rel_326, 6); +YAP_UserCPredicate("gecode_constraint_rel_327", gecode_constraint_rel_327, 6); +YAP_UserCPredicate("gecode_constraint_rel_328", gecode_constraint_rel_328, 6); +YAP_UserCPredicate("gecode_constraint_rel_329", gecode_constraint_rel_329, 6); +YAP_UserCPredicate("gecode_constraint_weights_364", gecode_constraint_weights_364, 5); +YAP_UserCPredicate("gecode_constraint_max_219", gecode_constraint_max_219, 5); +YAP_UserCPredicate("gecode_constraint_path_263", gecode_constraint_path_263, 9); +YAP_UserCPredicate("gecode_constraint_unary_358", gecode_constraint_unary_358, 4); +YAP_UserCPredicate("gecode_constraint_unary_354", gecode_constraint_unary_354, 4); +YAP_UserCPredicate("gecode_constraint_unary_348", gecode_constraint_unary_348, 4); +YAP_UserCPredicate("gecode_constraint_unary_351", gecode_constraint_unary_351, 4); +YAP_UserCPredicate("gecode_constraint_sorted_341", gecode_constraint_sorted_341, 5); +YAP_UserCPredicate("gecode_constraint_circuit_40", gecode_constraint_circuit_40, 5); +YAP_UserCPredicate("gecode_constraint_circuit_37", gecode_constraint_circuit_37, 5); +YAP_UserCPredicate("gecode_constraint_circuit_34", gecode_constraint_circuit_34, 5); +YAP_UserCPredicate("gecode_constraint_dom_142", gecode_constraint_dom_142, 4); +YAP_UserCPredicate("gecode_constraint_dom_136", gecode_constraint_dom_136, 4); +YAP_UserCPredicate("gecode_constraint_dom_141", gecode_constraint_dom_141, 4); +YAP_UserCPredicate("gecode_constraint_dom_132", gecode_constraint_dom_132, 4); +YAP_UserCPredicate("gecode_constraint_dom_135", gecode_constraint_dom_135, 4); +YAP_UserCPredicate("gecode_constraint_dom_130", gecode_constraint_dom_130, 4); +YAP_UserCPredicate("gecode_constraint_dom_129", gecode_constraint_dom_129, 4); +YAP_UserCPredicate("gecode_constraint_dom_127", gecode_constraint_dom_127, 4); +YAP_UserCPredicate("gecode_constraint_dom_146", gecode_constraint_dom_146, 4); +YAP_UserCPredicate("gecode_constraint_dom_144", gecode_constraint_dom_144, 4); +YAP_UserCPredicate("gecode_constraint_abs_1", gecode_constraint_abs_1, 3); +YAP_UserCPredicate("gecode_constraint_channel_29", gecode_constraint_channel_29, 5); +YAP_UserCPredicate("gecode_constraint_channel_24", gecode_constraint_channel_24, 5); +YAP_UserCPredicate("gecode_constraint_rel_304", gecode_constraint_rel_304, 3); +YAP_UserCPredicate("gecode_constraint_rel_296", gecode_constraint_rel_296, 3); +YAP_UserCPredicate("gecode_constraint_path_266", gecode_constraint_path_266, 4); +YAP_UserCPredicate("gecode_constraint_branch_14", gecode_constraint_branch_14, 4); +YAP_UserCPredicate("gecode_constraint_branch_13", gecode_constraint_branch_13, 4); +YAP_UserCPredicate("gecode_constraint_branch_15", gecode_constraint_branch_15, 4); +YAP_UserCPredicate("gecode_constraint_mult_239", gecode_constraint_mult_239, 5); +YAP_UserCPredicate("gecode_constraint_circuit_41", gecode_constraint_circuit_41, 6); +YAP_UserCPredicate("gecode_constraint_circuit_38", gecode_constraint_circuit_38, 6); +YAP_UserCPredicate("gecode_constraint_circuit_35", gecode_constraint_circuit_35, 6); +YAP_UserCPredicate("gecode_constraint_clause_48", gecode_constraint_clause_48, 5); +YAP_UserCPredicate("gecode_constraint_clause_46", gecode_constraint_clause_46, 5); +YAP_UserCPredicate("gecode_constraint_precede_275", gecode_constraint_precede_275, 4); +YAP_UserCPredicate("gecode_constraint_precede_272", gecode_constraint_precede_272, 4); +YAP_UserCPredicate("gecode_constraint_precede_271", gecode_constraint_precede_271, 4); +YAP_UserCPredicate("gecode_constraint_channel_30", gecode_constraint_channel_30, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_86", gecode_constraint_cumulative_86, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_89", gecode_constraint_cumulative_89, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_82", gecode_constraint_cumulative_82, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_85", gecode_constraint_cumulative_85, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_79", gecode_constraint_cumulative_79, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_98", gecode_constraint_cumulative_98, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_101", gecode_constraint_cumulative_101, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_94", gecode_constraint_cumulative_94, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_97", gecode_constraint_cumulative_97, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_91", gecode_constraint_cumulative_91, 7); +YAP_UserCPredicate("gecode_constraint_distinct_121", gecode_constraint_distinct_121, 3); +YAP_UserCPredicate("gecode_constraint_distinct_118", gecode_constraint_distinct_118, 3); +YAP_UserCPredicate("gecode_constraint_member_227", gecode_constraint_member_227, 5); +YAP_UserCPredicate("gecode_constraint_member_223", gecode_constraint_member_223, 5); +YAP_UserCPredicate("gecode_constraint_mod_236", gecode_constraint_mod_236, 4); +YAP_UserCPredicate("gecode_constraint_sqr_344", gecode_constraint_sqr_344, 3); +YAP_UserCPredicate("gecode_constraint_sequence_337", gecode_constraint_sequence_337, 7); +YAP_UserCPredicate("gecode_constraint_sequence_335", gecode_constraint_sequence_335, 7); +YAP_UserCPredicate("gecode_constraint_path_264", gecode_constraint_path_264, 7); +YAP_UserCPredicate("gecode_constraint_path_261", gecode_constraint_path_261, 7); +YAP_UserCPredicate("gecode_constraint_path_258", gecode_constraint_path_258, 7); +YAP_UserCPredicate("gecode_constraint_divmod_125", gecode_constraint_divmod_125, 6); +YAP_UserCPredicate("gecode_constraint_sorted_342", gecode_constraint_sorted_342, 3); +YAP_UserCPredicate("gecode_constraint_circuit_44", gecode_constraint_circuit_44, 3); +YAP_UserCPredicate("gecode_constraint_circuit_43", gecode_constraint_circuit_43, 3); +YAP_UserCPredicate("gecode_constraint_channel_31", gecode_constraint_channel_31, 3); +YAP_UserCPredicate("gecode_constraint_channel_28", gecode_constraint_channel_28, 3); +YAP_UserCPredicate("gecode_constraint_channel_26", gecode_constraint_channel_26, 3); +YAP_UserCPredicate("gecode_constraint_channel_22", gecode_constraint_channel_22, 3); +YAP_UserCPredicate("gecode_constraint_channel_25", gecode_constraint_channel_25, 3); +YAP_UserCPredicate("gecode_constraint_channel_20", gecode_constraint_channel_20, 3); +YAP_UserCPredicate("gecode_constraint_count_52", gecode_constraint_count_52, 5); +YAP_UserCPredicate("gecode_constraint_count_54", gecode_constraint_count_54, 5); +YAP_UserCPredicate("gecode_constraint_count_70", gecode_constraint_count_70, 5); +YAP_UserCPredicate("gecode_constraint_count_72", gecode_constraint_count_72, 5); +YAP_UserCPredicate("gecode_constraint_count_62", gecode_constraint_count_62, 5); +YAP_UserCPredicate("gecode_constraint_count_64", gecode_constraint_count_64, 5); +YAP_UserCPredicate("gecode_constraint_count_61", gecode_constraint_count_61, 5); +YAP_UserCPredicate("gecode_constraint_count_57", gecode_constraint_count_57, 5); +YAP_UserCPredicate("gecode_constraint_count_67", gecode_constraint_count_67, 5); +YAP_UserCPredicate("gecode_constraint_count_74", gecode_constraint_count_74, 5); +YAP_UserCPredicate("gecode_constraint_count_76", gecode_constraint_count_76, 5); +YAP_UserCPredicate("gecode_constraint_cumulatives_116", gecode_constraint_cumulatives_116, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_114", gecode_constraint_cumulatives_114, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_112", gecode_constraint_cumulatives_112, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_110", gecode_constraint_cumulatives_110, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_108", gecode_constraint_cumulatives_108, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_106", gecode_constraint_cumulatives_106, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_104", gecode_constraint_cumulatives_104, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_102", gecode_constraint_cumulatives_102, 8); +YAP_UserCPredicate("gecode_constraint_binpacking_11", gecode_constraint_binpacking_11, 5); +YAP_UserCPredicate("gecode_constraint_linear_209", gecode_constraint_linear_209, 6); +YAP_UserCPredicate("gecode_constraint_linear_213", gecode_constraint_linear_213, 6); +YAP_UserCPredicate("gecode_constraint_linear_185", gecode_constraint_linear_185, 6); +YAP_UserCPredicate("gecode_constraint_linear_189", gecode_constraint_linear_189, 6); +YAP_UserCPredicate("gecode_constraint_linear_200", gecode_constraint_linear_200, 6); +YAP_UserCPredicate("gecode_constraint_linear_203", gecode_constraint_linear_203, 6); +YAP_UserCPredicate("gecode_constraint_linear_204", gecode_constraint_linear_204, 6); +YAP_UserCPredicate("gecode_constraint_linear_207", gecode_constraint_linear_207, 6); +YAP_UserCPredicate("gecode_constraint_linear_192", gecode_constraint_linear_192, 6); +YAP_UserCPredicate("gecode_constraint_linear_195", gecode_constraint_linear_195, 6); +YAP_UserCPredicate("gecode_constraint_linear_196", gecode_constraint_linear_196, 6); +YAP_UserCPredicate("gecode_constraint_linear_199", gecode_constraint_linear_199, 6); +YAP_UserCPredicate("gecode_constraint_nooverlap_246", gecode_constraint_nooverlap_246, 7); +YAP_UserCPredicate("gecode_constraint_nooverlap_241", gecode_constraint_nooverlap_241, 7); +YAP_UserCPredicate("gecode_constraint_div_123", gecode_constraint_div_123, 5); +YAP_UserCPredicate("gecode_constraint_sqr_345", gecode_constraint_sqr_345, 4); +YAP_UserCPredicate("gecode_constraint_path_265", gecode_constraint_path_265, 8); +YAP_UserCPredicate("gecode_constraint_path_262", gecode_constraint_path_262, 8); +YAP_UserCPredicate("gecode_constraint_path_259", gecode_constraint_path_259, 8); +YAP_UserCPredicate("gecode_constraint_unary_356", gecode_constraint_unary_356, 5); +YAP_UserCPredicate("gecode_constraint_unary_359", gecode_constraint_unary_359, 5); +YAP_UserCPredicate("gecode_constraint_unary_352", gecode_constraint_unary_352, 5); +YAP_UserCPredicate("gecode_constraint_unary_355", gecode_constraint_unary_355, 5); +YAP_UserCPredicate("gecode_constraint_unary_349", gecode_constraint_unary_349, 5); +YAP_UserCPredicate("gecode_constraint_sorted_340", gecode_constraint_sorted_340, 4); +YAP_UserCPredicate("gecode_constraint_sorted_343", gecode_constraint_sorted_343, 4); +YAP_UserCPredicate("gecode_constraint_element_161", gecode_constraint_element_161, 8); +YAP_UserCPredicate("gecode_constraint_element_155", gecode_constraint_element_155, 8); +YAP_UserCPredicate("gecode_constraint_element_173", gecode_constraint_element_173, 8); +YAP_UserCPredicate("gecode_constraint_element_171", gecode_constraint_element_171, 8); +YAP_UserCPredicate("gecode_constraint_element_159", gecode_constraint_element_159, 5); +YAP_UserCPredicate("gecode_constraint_element_163", gecode_constraint_element_163, 5); +YAP_UserCPredicate("gecode_constraint_element_153", gecode_constraint_element_153, 5); +YAP_UserCPredicate("gecode_constraint_element_151", gecode_constraint_element_151, 5); +YAP_UserCPredicate("gecode_constraint_element_182", gecode_constraint_element_182, 5); +YAP_UserCPredicate("gecode_constraint_element_180", gecode_constraint_element_180, 5); +YAP_UserCPredicate("gecode_constraint_element_178", gecode_constraint_element_178, 5); +YAP_UserCPredicate("gecode_constraint_element_176", gecode_constraint_element_176, 5); +YAP_UserCPredicate("gecode_constraint_element_169", gecode_constraint_element_169, 5); +YAP_UserCPredicate("gecode_constraint_element_175", gecode_constraint_element_175, 5); +YAP_UserCPredicate("gecode_constraint_element_167", gecode_constraint_element_167, 5); +YAP_UserCPredicate("gecode_constraint_sequence_339", gecode_constraint_sequence_339, 3); +YAP_UserCPredicate("gecode_constraint_circuit_39", gecode_constraint_circuit_39, 7); +YAP_UserCPredicate("gecode_constraint_precede_274", gecode_constraint_precede_274, 3); +YAP_UserCPredicate("gecode_constraint_precede_270", gecode_constraint_precede_270, 3); +YAP_UserCPredicate("gecode_constraint_cumulative_88", gecode_constraint_cumulative_88, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_84", gecode_constraint_cumulative_84, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_78", gecode_constraint_cumulative_78, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_81", gecode_constraint_cumulative_81, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_100", gecode_constraint_cumulative_100, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_96", gecode_constraint_cumulative_96, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_90", gecode_constraint_cumulative_90, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_93", gecode_constraint_cumulative_93, 6); +YAP_UserCPredicate("gecode_constraint_distinct_119", gecode_constraint_distinct_119, 4); +YAP_UserCPredicate("gecode_constraint_min_230", gecode_constraint_min_230, 3); +YAP_UserCPredicate("gecode_constraint_min_234", gecode_constraint_min_234, 3); +YAP_UserCPredicate("gecode_constraint_sqrt_347", gecode_constraint_sqrt_347, 4); +YAP_UserCPredicate("gecode_constraint_sequence_336", gecode_constraint_sequence_336, 6); +YAP_UserCPredicate("gecode_constraint_sequence_334", gecode_constraint_sequence_334, 6); +YAP_UserCPredicate("gecode_constraint_unshare_363", gecode_constraint_unshare_363, 3); +YAP_UserCPredicate("gecode_constraint_unshare_361", gecode_constraint_unshare_361, 3); +YAP_UserCPredicate("gecode_constraint_path_269", gecode_constraint_path_269, 6); +YAP_UserCPredicate("gecode_constraint_path_260", gecode_constraint_path_260, 6); +YAP_UserCPredicate("gecode_constraint_divmod_124", gecode_constraint_divmod_124, 5); +YAP_UserCPredicate("gecode_constraint_nooverlap_245", gecode_constraint_nooverlap_245, 9); +YAP_UserCPredicate("gecode_constraint_cumulative_80", gecode_constraint_cumulative_80, 5); +YAP_UserCPredicate("gecode_constraint_cumulative_92", gecode_constraint_cumulative_92, 5); +YAP_UserCPredicate("gecode_constraint_member_228", gecode_constraint_member_228, 3); +YAP_UserCPredicate("gecode_constraint_member_224", gecode_constraint_member_224, 3); +YAP_UserCPredicate("gecode_constraint_count_71", gecode_constraint_count_71, 6); +YAP_UserCPredicate("gecode_constraint_count_73", gecode_constraint_count_73, 6); +YAP_UserCPredicate("gecode_constraint_count_75", gecode_constraint_count_75, 6); +YAP_UserCPredicate("gecode_constraint_count_77", gecode_constraint_count_77, 6); +YAP_UserCPredicate("gecode_constraint_count_63", gecode_constraint_count_63, 6); +YAP_UserCPredicate("gecode_constraint_count_65", gecode_constraint_count_65, 6); +YAP_UserCPredicate("gecode_constraint_count_53", gecode_constraint_count_53, 6); +YAP_UserCPredicate("gecode_constraint_count_55", gecode_constraint_count_55, 6); +YAP_UserCPredicate("gecode_constraint_notMin_249", gecode_constraint_notMin_249, 3); +YAP_UserCPredicate("gecode_constraint_cumulative_87", gecode_constraint_cumulative_87, 8); +YAP_UserCPredicate("gecode_constraint_cumulative_83", gecode_constraint_cumulative_83, 8); +YAP_UserCPredicate("gecode_constraint_cumulative_99", gecode_constraint_cumulative_99, 8); +YAP_UserCPredicate("gecode_constraint_cumulative_95", gecode_constraint_cumulative_95, 8); +YAP_UserCPredicate("gecode_constraint_branch_16", gecode_constraint_branch_16, 3); +YAP_UserCPredicate("gecode_constraint_branch_12", gecode_constraint_branch_12, 3); +YAP_UserCPredicate("gecode_constraint_branch_17", gecode_constraint_branch_17, 3); +YAP_UserCPredicate("gecode_constraint_dom_140", gecode_constraint_dom_140, 3); +YAP_UserCPredicate("gecode_constraint_dom_134", gecode_constraint_dom_134, 3); +YAP_UserCPredicate("gecode_constraint_dom_128", gecode_constraint_dom_128, 3); +YAP_UserCPredicate("gecode_constraint_dom_126", gecode_constraint_dom_126, 3); +YAP_UserCPredicate("gecode_constraint_linear_208", gecode_constraint_linear_208, 5); +YAP_UserCPredicate("gecode_constraint_linear_211", gecode_constraint_linear_211, 5); +YAP_UserCPredicate("gecode_constraint_linear_212", gecode_constraint_linear_212, 5); +YAP_UserCPredicate("gecode_constraint_linear_215", gecode_constraint_linear_215, 5); +YAP_UserCPredicate("gecode_constraint_linear_184", gecode_constraint_linear_184, 5); +YAP_UserCPredicate("gecode_constraint_linear_187", gecode_constraint_linear_187, 5); +YAP_UserCPredicate("gecode_constraint_linear_188", gecode_constraint_linear_188, 5); +YAP_UserCPredicate("gecode_constraint_linear_191", gecode_constraint_linear_191, 5); +YAP_UserCPredicate("gecode_constraint_linear_202", gecode_constraint_linear_202, 5); +YAP_UserCPredicate("gecode_constraint_linear_206", gecode_constraint_linear_206, 5); +YAP_UserCPredicate("gecode_constraint_linear_194", gecode_constraint_linear_194, 5); +YAP_UserCPredicate("gecode_constraint_linear_198", gecode_constraint_linear_198, 5); +YAP_UserCPredicate("gecode_constraint_nooverlap_240", gecode_constraint_nooverlap_240, 6); +YAP_UserCPredicate("gecode_constraint_nooverlap_243", gecode_constraint_nooverlap_243, 6); +YAP_UserCPredicate("gecode_constraint_element_183", gecode_constraint_element_183, 6); +YAP_UserCPredicate("gecode_constraint_element_181", gecode_constraint_element_181, 6); +YAP_UserCPredicate("gecode_constraint_element_179", gecode_constraint_element_179, 6); +YAP_UserCPredicate("gecode_constraint_element_177", gecode_constraint_element_177, 6); +YAP_UserCPredicate("gecode_constraint_rel_290", gecode_constraint_rel_290, 4); +YAP_UserCPredicate("gecode_constraint_rel_286", gecode_constraint_rel_286, 4); +YAP_UserCPredicate("gecode_constraint_rel_298", gecode_constraint_rel_298, 4); +YAP_UserCPredicate("gecode_constraint_rel_294", gecode_constraint_rel_294, 4); +YAP_UserCPredicate("gecode_constraint_rel_292", gecode_constraint_rel_292, 4); +YAP_UserCPredicate("gecode_constraint_rel_297", gecode_constraint_rel_297, 4); +YAP_UserCPredicate("gecode_constraint_rel_324", gecode_constraint_rel_324, 4); +YAP_UserCPredicate("gecode_constraint_rel_322", gecode_constraint_rel_322, 4); +YAP_UserCPredicate("gecode_constraint_rel_306", gecode_constraint_rel_306, 4); +YAP_UserCPredicate("gecode_constraint_rel_308", gecode_constraint_rel_308, 4); +YAP_UserCPredicate("gecode_constraint_rel_302", gecode_constraint_rel_302, 4); +YAP_UserCPredicate("gecode_constraint_rel_305", gecode_constraint_rel_305, 4); +YAP_UserCPredicate("gecode_constraint_rel_312", gecode_constraint_rel_312, 4); +YAP_UserCPredicate("gecode_constraint_rel_316", gecode_constraint_rel_316, 4); +YAP_UserCPredicate("gecode_constraint_rel_318", gecode_constraint_rel_318, 4); +YAP_UserCPredicate("gecode_constraint_rel_319", gecode_constraint_rel_319, 4); +YAP_UserCPredicate("gecode_constraint_rel_325", gecode_constraint_rel_325, 4); +YAP_UserCPredicate("gecode_constraint_rel_330", gecode_constraint_rel_330, 4); +YAP_UserCPredicate("gecode_constraint_rel_332", gecode_constraint_rel_332, 4); +YAP_UserCPredicate("gecode_constraint_rel_278", gecode_constraint_rel_278, 4); +YAP_UserCPredicate("gecode_constraint_rel_276", gecode_constraint_rel_276, 4); +YAP_UserCPredicate("gecode_constraint_min_233", gecode_constraint_min_233, 5); +YAP_UserCPredicate("gecode_constraint_count_68", gecode_constraint_count_68, 3); +YAP_UserCPredicate("gecode_constraint_count_58", gecode_constraint_count_58, 3); diff --git a/library/gecode/dev/gecode-enums-3.7.3.py b/library/gecode/dev/gecode-enums-3.7.3.py new file mode 100644 index 000000000..f2d84a057 --- /dev/null +++ b/library/gecode/dev/gecode-enums-3.7.3.py @@ -0,0 +1,113 @@ +# This file was automatically extracted from Gecode source files. +# It is subject to the same Copyright as the source files from which +# it is derived, and is distributed under the same Licensing conditions. +ENUM_CLASSES = [] + +class ScriptMode(object): + TYPE = 'ScriptMode' + ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST'] + +ENUM_CLASSES.append(ScriptMode) + +class IntRelType(object): + TYPE = 'IntRelType' + ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR'] + +ENUM_CLASSES.append(IntRelType) + +class BoolOpType(object): + TYPE = 'BoolOpType' + ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR'] + +ENUM_CLASSES.append(BoolOpType) + +class IntConLevel(object): + TYPE = 'IntConLevel' + ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF'] + +ENUM_CLASSES.append(IntConLevel) + +class TaskType(object): + TYPE = 'TaskType' + ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE'] + +ENUM_CLASSES.append(TaskType) + +class ExtensionalPropKind(object): + TYPE = 'ExtensionalPropKind' + ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY'] + +ENUM_CLASSES.append(ExtensionalPropKind) + +class IntVarBranch(object): + TYPE = 'IntVarBranch' + ENUM = ['INT_VAR_NONE','INT_VAR_RND','INT_VAR_DEGREE_MIN','INT_VAR_DEGREE_MAX','INT_VAR_AFC_MIN','INT_VAR_AFC_MAX','INT_VAR_MIN_MIN','INT_VAR_MIN_MAX','INT_VAR_MAX_MIN','INT_VAR_MAX_MAX','INT_VAR_SIZE_MIN','INT_VAR_SIZE_MAX','INT_VAR_SIZE_DEGREE_MIN','INT_VAR_SIZE_DEGREE_MAX','INT_VAR_SIZE_AFC_MIN','INT_VAR_SIZE_AFC_MAX','INT_VAR_REGRET_MIN_MIN','INT_VAR_REGRET_MIN_MAX','INT_VAR_REGRET_MAX_MIN','INT_VAR_REGRET_MAX_MAX'] + +ENUM_CLASSES.append(IntVarBranch) + +class IntValBranch(object): + TYPE = 'IntValBranch' + ENUM = ['INT_VAL_MIN','INT_VAL_MED','INT_VAL_MAX','INT_VAL_RND','INT_VAL_SPLIT_MIN','INT_VAL_SPLIT_MAX','INT_VAL_RANGE_MIN','INT_VAL_RANGE_MAX','INT_VALUES_MIN','INT_VALUES_MAX'] + +ENUM_CLASSES.append(IntValBranch) + +class IntAssign(object): + TYPE = 'IntAssign' + ENUM = ['INT_ASSIGN_MIN','INT_ASSIGN_MED','INT_ASSIGN_MAX','INT_ASSIGN_RND'] + +ENUM_CLASSES.append(IntAssign) + +class ViewSelStatus(object): + TYPE = 'ViewSelStatus' + ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE'] + +ENUM_CLASSES.append(ViewSelStatus) + +class ExecStatus(object): + TYPE = 'ExecStatus' + ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL'] + +ENUM_CLASSES.append(ExecStatus) + +class ActorProperty(object): + TYPE = 'ActorProperty' + ENUM = ['AP_DISPOSE','AP_WEAKLY'] + +ENUM_CLASSES.append(ActorProperty) + +class SpaceStatus(object): + TYPE = 'SpaceStatus' + ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH'] + +ENUM_CLASSES.append(SpaceStatus) + +class SetRelType(object): + TYPE = 'SetRelType' + ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL','SRT_LQ','SRT_LE','SRT_GQ','SRT_GR'] + +ENUM_CLASSES.append(SetRelType) + +class SetOpType(object): + TYPE = 'SetOpType' + ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS'] + +ENUM_CLASSES.append(SetOpType) + +class SetVarBranch(object): + TYPE = 'SetVarBranch' + ENUM = ['SET_VAR_NONE','SET_VAR_RND','SET_VAR_DEGREE_MIN','SET_VAR_DEGREE_MAX','SET_VAR_AFC_MIN','SET_VAR_AFC_MAX','SET_VAR_MIN_MIN','SET_VAR_MIN_MAX','SET_VAR_MAX_MIN','SET_VAR_MAX_MAX','SET_VAR_SIZE_MIN','SET_VAR_SIZE_MAX','SET_VAR_SIZE_DEGREE_MIN','SET_VAR_SIZE_DEGREE_MAX','SET_VAR_SIZE_AFC_MIN','SET_VAR_SIZE_AFC_MAX'] + +ENUM_CLASSES.append(SetVarBranch) + +class SetValBranch(object): + TYPE = 'SetValBranch' + ENUM = ['SET_VAL_MIN_INC','SET_VAL_MIN_EXC','SET_VAL_MED_INC','SET_VAL_MED_EXC','SET_VAL_MAX_INC','SET_VAL_MAX_EXC','SET_VAL_RND_INC','SET_VAL_RND_EXC'] + +ENUM_CLASSES.append(SetValBranch) + +class SetAssign(object): + TYPE = 'SetAssign' + ENUM = ['SET_ASSIGN_MIN_INC','SET_ASSIGN_MIN_EXC','SET_ASSIGN_MED_INC','SET_ASSIGN_MED_EXC','SET_ASSIGN_MAX_INC','SET_ASSIGN_MAX_EXC','SET_ASSIGN_RND_INC','SET_ASSIGN_RND_EXC'] + +ENUM_CLASSES.append(SetAssign) + diff --git a/library/gecode/dev/gecode-prototypes-3.7.3.hh b/library/gecode/dev/gecode-prototypes-3.7.3.hh new file mode 100644 index 000000000..a0120ac9d --- /dev/null +++ b/library/gecode/dev/gecode-prototypes-3.7.3.hh @@ -0,0 +1,221 @@ +// This file was automatically extracted from Gecode source files. +// It is subject to the same Copyright as the source files from which +// it is derived, and is distributed under the same Licensing conditions. +void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF); +void assign(Home,BoolVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def); +void assign(Home,const BoolVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def); +void assign(Home,const IntVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def); +void assign(Home,const SetVarArgs&,SetAssign,const ValBranchOptions&=ValBranchOptions::def); +void assign(Home,IntVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def); +void assign(Home,SetVar,SetAssign,const ValBranchOptions&=ValBranchOptions::def); +void atmostOne(Home,const SetVarArgs&,unsigned int); +void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void branch(Home,BoolVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def); +void branch(Home,const BoolVarArgs&,const TieBreakVarBranch&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def); +void branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def); +void branch(Home,const IntVarArgs&,const TieBreakVarBranch&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def); +void branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def); +void branch(Home,const SetVarArgs&,const TieBreakVarBranch&,SetValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def); +void branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def); +void branch(Home,IntVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def); +void branch(Home,SetVar,SetValBranch,const ValBranchOptions&=ValBranchOptions::def); +void cardinality(Home,SetVar,IntVar); +void cardinality(Home,SetVar,unsigned int,unsigned int); +void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF); +void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF); +void channel(Home,const BoolVarArgs&,SetVar); +void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF); +void channel(Home,const IntVarArgs&,const SetVarArgs&); +void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF); +void channel(Home,IntVar,BoolVar,IntConLevel=ICL_DEF); +void channelSorted(Home,const IntVarArgs&,SetVar); +void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF); +void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF); +void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF); +void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF); +void convex(Home,SetVar); +void convex(Home,SetVar,SetVar); +void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,const IntSet&,IntRelType,int,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,const IntSet&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF); +void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF); +void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF); +void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF); +void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF); +void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF); +void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF); +void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF); +void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF); +void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF); +void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF); +void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF); +void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF); +void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF); +void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF); +void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF); +void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF); +void dom(Home,IntVar,const IntSet&,BoolVar,IntConLevel=ICL_DEF); +void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF); +void dom(Home,IntVar,int,BoolVar,IntConLevel=ICL_DEF); +void dom(Home,IntVar,int,int,BoolVar,IntConLevel=ICL_DEF); +void dom(Home,IntVar,int,IntConLevel=ICL_DEF); +void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF); +void dom(Home,SetVar,SetRelType,const IntSet&); +void dom(Home,SetVar,SetRelType,const IntSet&,BoolVar); +void dom(Home,SetVar,SetRelType,int); +void dom(Home,SetVar,SetRelType,int,BoolVar); +void dom(Home,SetVar,SetRelType,int,int); +void dom(Home,SetVar,SetRelType,int,int,BoolVar); +void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF); +void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF); +void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF); +void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar); +void element(Home,const IntSetArgs&,IntVar,SetVar); +void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF); +void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF); +void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF); +void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar); +void element(Home,const SetVarArgs&,IntVar,SetVar); +void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF); +void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF); +void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF); +void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF); +void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF); +void element(Home,SetOpType,const IntArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max)); +void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max)); +void element(Home,SetOpType,const IntVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max)); +void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max)); +void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF); +void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF); +void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF); +void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF); +void linear(Home,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF); +void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void linear(Home,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF); +void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF); +void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF); +void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF); +void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF); +void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void linear(Home,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF); +void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void linear(Home,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF); +void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF); +void max(Home,SetVar,IntVar); +void max(Home,SetVar,IntVar,BoolVar); +void member(Home,const BoolVarArgs&,BoolVar,BoolVar,IntConLevel=ICL_DEF); +void member(Home,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF); +void member(Home,const IntVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF); +void member(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF); +void min(Home,SetVar,IntVar); +void min(Home,SetVar,IntVar,BoolVar); +void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF); +void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF); +void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF); +void notMax(Home,SetVar,IntVar); +void notMin(Home,SetVar,IntVar); +void nvalues(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void nvalues(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void nvalues(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void nvalues(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF); +void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF); +void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF); +void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF); +void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF); +void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF); +void precede(Home,const SetVarArgs&,const IntArgs&); +void precede(Home,const SetVarArgs&,int,int); +void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF); +void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF); +void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF); +void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF); +void rel(Home,BoolVar,IntRelType,BoolVar,BoolVar,IntConLevel=ICL_DEF); +void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF); +void rel(Home,BoolVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF); +void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF); +void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF); +void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF); +void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF); +void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&); +void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar); +void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF); +void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF); +void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF); +void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF); +void rel(Home,IntVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF); +void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF); +void rel(Home,IntVar,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF); +void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF); +void rel(Home,IntVar,IntRelType,SetVar); +void rel(Home,IntVar,SetRelType,SetVar); +void rel(Home,IntVar,SetRelType,SetVar,BoolVar); +void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar); +void rel(Home,SetOpType,const IntVarArgs&,SetVar); +void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar); +void rel(Home,SetOpType,const SetVarArgs&,SetVar); +void rel(Home,SetVar,IntRelType,IntVar); +void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&); +void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar); +void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&); +void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar); +void rel(Home,SetVar,SetRelType,IntVar); +void rel(Home,SetVar,SetRelType,IntVar,BoolVar); +void rel(Home,SetVar,SetRelType,SetVar); +void rel(Home,SetVar,SetRelType,SetVar,BoolVar); +void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF); +void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF); +void sequence(Home,const SetVarArgs&); +void sequence(Home,const SetVarArgs&,SetVar); +void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF); +void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF); +void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF); +void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF); +void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF); +void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF); +void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF); +void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF); +void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF); +void weights(Home,IntSharedArray,IntSharedArray,SetVar,IntVar);