diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
f29e017c63
yap-6.3/packages/gecode/4.2.0/gecode_yap_auto_generated.yap

3517 lines
214 KiB
Plaintext
Raw Normal View History

distributed config && float library
2013-11-03 14:12:38 +00:00
%% -*- 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 <http://www.gnu.org/licenses/>.
%%=============================================================================
is_RestartMode_('RM_NONE').
is_RestartMode_('RM_CONSTANT').
is_RestartMode_('RM_LINEAR').
is_RestartMode_('RM_LUBY').
is_RestartMode_('RM_GEOMETRIC').
is_RestartMode_('RM_NONE','RM_NONE').
is_RestartMode_('RM_CONSTANT','RM_CONSTANT').
is_RestartMode_('RM_LINEAR','RM_LINEAR').
is_RestartMode_('RM_LUBY','RM_LUBY').
is_RestartMode_('RM_GEOMETRIC','RM_GEOMETRIC').
is_RestartMode(X,Y) :- nonvar(X), is_RestartMode_(X,Y).
is_RestartMode(X) :- is_RestartMode(X,_).
is_FloatRelType_('FRT_EQ').
is_FloatRelType_('FRT_NQ').
is_FloatRelType_('FRT_LQ').
is_FloatRelType_('FRT_LE').
is_FloatRelType_('FRT_GQ').
is_FloatRelType_('FRT_GR').
is_FloatRelType_('FRT_EQ','FRT_EQ').
is_FloatRelType_('FRT_NQ','FRT_NQ').
is_FloatRelType_('FRT_LQ','FRT_LQ').
is_FloatRelType_('FRT_LE','FRT_LE').
is_FloatRelType_('FRT_GQ','FRT_GQ').
is_FloatRelType_('FRT_GR','FRT_GR').
is_FloatRelType(X,Y) :- nonvar(X), is_FloatRelType_(X,Y).
is_FloatRelType(X) :- is_FloatRelType(X,_).
is_ReifyMode_('RM_EQV').
is_ReifyMode_('RM_IMP').
is_ReifyMode_('RM_PMI').
is_ReifyMode_('RM_EQV','RM_EQV').
is_ReifyMode_('RM_IMP','RM_IMP').
is_ReifyMode_('RM_PMI','RM_PMI').
is_ReifyMode(X,Y) :- nonvar(X), is_ReifyMode_(X,Y).
is_ReifyMode(X) :- is_ReifyMode(X,_).
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_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,_).
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_458(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_454(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_345(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_347(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_341(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_343(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_302(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_300(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_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> (is_FloatVar(X3,Y3)
-> gecode_constraint_max_301(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_Reify(X3,Y3)
-> gecode_constraint_max_305(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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_dom_200(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_Reify(X5,Y5)
-> gecode_constraint_dom_209(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_91(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_329(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_FloatVar(X1,Y1)
-> (is_FloatAssign(X2,Y2)
-> gecode_constraint_assign_15(Y0,Y1,Y2)
; throw(gecode_argument_error(assign(X0,X1,X2),arg=3)))
; (is_FloatVarArgs(X1,Y1)
-> (is_FloatAssign(X2,Y2)
-> gecode_constraint_assign_6(Y0,Y1,Y2)
; throw(gecode_argument_error(assign(X0,X1,X2),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> gecode_constraint_assign_3(Y0,Y1,Y2)
; throw(gecode_argument_error(assign(X0,X1,X2),arg=3)))
; (is_BoolVar(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> gecode_constraint_assign_1(Y0,Y1,Y2)
; throw(gecode_argument_error(assign(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> gecode_constraint_assign_9(Y0,Y1,Y2)
; throw(gecode_argument_error(assign(X0,X1,X2),arg=3)))
; (is_IntVar(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> gecode_constraint_assign_17(Y0,Y1,Y2)
; throw(gecode_argument_error(assign(X0,X1,X2),arg=3)))
; (is_SetVarArgs(X1,Y1)
-> (is_SetAssign(X2,Y2)
-> gecode_constraint_assign_12(Y0,Y1,Y2)
; throw(gecode_argument_error(assign(X0,X1,X2),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_SetAssign(X2,Y2)
-> gecode_constraint_assign_19(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_220(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
-> gecode_constraint_element_224(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_214(Y0,Y1,Y2,Y3)
; (is_BoolVar(X3,Y3)
-> gecode_constraint_element_212(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_219(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_227(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_230(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
-> gecode_constraint_element_236(Y0,Y1,Y2,Y3)
; (is_BoolVar(X3,Y3)
-> gecode_constraint_element_228(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_437(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_335(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))).
ite(X0,X1,X2,X3,X4) :-
(is_Space_or_Clause(X0,Y0)
-> (is_BoolVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntVar(X4,Y4)
-> gecode_constraint_ite_256(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=3)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=2)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=1))).
unary(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_IntArgs(X2,Y2)
-> gecode_constraint_unary_451(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))).
nroot(X0,X1,X2,X3,X4) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
-> gecode_constraint_nroot_339(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=3)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=2)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),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_85(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_76(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_Reify(X4,Y4)
-> gecode_constraint_dom_199(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_dom_198(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))))
; (is_Reify(X3,Y3)
-> (is_IntConLevel(X4,Y4)
-> gecode_constraint_dom_202(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_Reify(X3,Y3)
-> (is_IntConLevel(X4,Y4)
-> gecode_constraint_dom_194(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_SetVarArgs(X1,Y1)
-> (is_SetRelType(X2,Y2)
-> (is_int(X3,Y3)
-> (is_int(X4,Y4)
-> gecode_constraint_dom_185(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_181(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_FloatVar(X1,Y1)
-> (is_FloatNum(X2,Y2)
-> (is_FloatNum(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_dom_187(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_208(Y0,Y1,Y2,Y3,Y4)
; (is_Reify(X4,Y4)
-> gecode_constraint_dom_210(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))))
; (is_IntSet(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_dom_206(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_IntVarArgs(X1,Y1)
-> (is_IntVarArgs(X2,Y2)
-> (is_IntConLevel(X3,Y3)
-> gecode_constraint_channel_66(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_62(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_60(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_331(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
; (is_IntConLevel(X7,Y7)
-> gecode_constraint_nooverlap_334(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_222(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_216(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_218(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_226(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_234(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; (is_BoolVar(X6,Y6)
-> gecode_constraint_element_232(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_FloatVarArgs(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> gecode_constraint_max_298(Y0,Y1,Y2)
; throw(gecode_argument_error(max(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
-> gecode_constraint_max_299(Y0,Y1,Y2)
; throw(gecode_argument_error(max(X0,X1,X2),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> gecode_constraint_max_304(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_463(Y0,Y1)
; (is_BoolVarArgs(X1,Y1)
-> gecode_constraint_unshare_461(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_358(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_357(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))).
branch(X0,X1,X2,X3,X4,X5,X6) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_IntVarBranch(X2,Y2)
-> (is_IntValBranch(X3,Y3)
-> (is_Symmetries(X4,Y4)
-> (is_IntBranchFilter(X5,Y5)
-> (is_IntVarValPrint(X6,Y6)
-> gecode_constraint_branch_34(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=5)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntVarBranch(X2,Y2)
-> (is_IntValBranch(X3,Y3)
-> (is_Symmetries(X4,Y4)
-> (is_BoolBranchFilter(X5,Y5)
-> (is_BoolVarValPrint(X6,Y6)
-> gecode_constraint_branch_28(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=5)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=3)))
; (is_SetVarArgs(X1,Y1)
-> (is_SetVarBranch(X2,Y2)
-> (is_SetValBranch(X3,Y3)
-> (is_Symmetries(X4,Y4)
-> (is_SetBranchFilter(X5,Y5)
-> (is_SetVarValPrint(X6,Y6)
-> gecode_constraint_branch_40(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=5)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=3)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=2)))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),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_325(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)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> (is_FloatVar(X3,Y3)
-> gecode_constraint_mult_324(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_89(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_87(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_366(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_160(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_Reify(X3,Y3)
-> gecode_constraint_member_312(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_member_311(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_Reify(X3,Y3)
-> gecode_constraint_member_308(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_member_307(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_323(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_57(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_53(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_73(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))).
extensional(X0,X1,X2,X3,X4) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_TupleSet(X2,Y2)
-> (is_ExtensionalPropKind(X3,Y3)
-> (is_IntConLevel(X4,Y4)
-> gecode_constraint_extensional_253(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_TupleSet(X2,Y2)
-> (is_ExtensionalPropKind(X3,Y3)
-> (is_IntConLevel(X4,Y4)
-> gecode_constraint_extensional_248(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=3)))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=2))))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=1))).
linear(X0,X1,X2,X3) :-
(is_Space_or_Clause(X0,Y0)
-> (is_FloatVarArgs(X1,Y1)
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVar(X3,Y3)
-> gecode_constraint_linear_272(Y0,Y1,Y2,Y3)
; (is_FloatNum(X3,Y3)
-> gecode_constraint_linear_270(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_258(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
-> gecode_constraint_linear_262(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_IntVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> gecode_constraint_linear_290(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
-> gecode_constraint_linear_294(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_82(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_FloatVar(X1,Y1)
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVal(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_rel_406(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_FloatVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_rel_408(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_422(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_420(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_392(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_388(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_386(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_BoolVar(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_rel_383(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_rel_382(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))))
; (is_BoolVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_rel_379(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_rel_378(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_375(Y0,Y1,Y2,Y3,Y4)
; (is_BoolVar(X4,Y4)
-> gecode_constraint_rel_373(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_402(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_404(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_398(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_Reify(X4,Y4)
-> gecode_constraint_rel_411(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_rel_410(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))))
; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_rel_415(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_rel_414(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_Reify(X4,Y4)
-> gecode_constraint_rel_419(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_Reify(X4,Y4)
-> gecode_constraint_rel_430(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_SetVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_rel_432(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_372(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_370(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_318(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_316(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_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> (is_FloatVar(X3,Y3)
-> gecode_constraint_min_317(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_Reify(X3,Y3)
-> gecode_constraint_min_321(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_SetVarArgs(X1,Y1)
-> (is_int(X2,Y2)
-> (is_int(X3,Y3)
-> gecode_constraint_cardinality_56(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)))
; (is_SetVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_int(X3,Y3)
-> gecode_constraint_cardinality_58(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_109(Y0,Y1,Y2,Y3)
; (is_IntArgs(X3,Y3)
-> gecode_constraint_count_106(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_100(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_99(Y0,Y1,Y2,Y3)
; (is_IntArgs(X3,Y3)
-> gecode_constraint_count_96(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_447(Y0,Y1,Y2)
; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> gecode_constraint_sqrt_446(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_157(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_155(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_153(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_151(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_149(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_147(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_145(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_143(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_344(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
-> gecode_constraint_nvalues_346(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_340(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
-> gecode_constraint_nvalues_342(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_54(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_Reify(X5,Y5)
-> (is_IntConLevel(X6,Y6)
-> gecode_constraint_linear_285(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_Reify(X5,Y5)
-> (is_IntConLevel(X6,Y6)
-> gecode_constraint_linear_289(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_Reify(X5,Y5)
-> (is_IntConLevel(X6,Y6)
-> gecode_constraint_linear_277(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_Reify(X5,Y5)
-> (is_IntConLevel(X6,Y6)
-> gecode_constraint_linear_281(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_52(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_90(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_163(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)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> (is_FloatVar(X3,Y3)
-> gecode_constraint_div_162(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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_rel_412(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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_rel_416(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_395(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_SetVar(X5,Y5)
-> gecode_constraint_rel_396(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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_rel_384(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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_rel_380(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_376(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_374(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_425(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_SetVar(X5,Y5)
-> gecode_constraint_rel_426(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_427(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_SetVar(X5,Y5)
-> gecode_constraint_rel_428(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_465(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_303(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_353(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_459(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_455(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_449(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_unary_452(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))).
nroot(X0,X1,X2,X3) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_IntVar(X3,Y3)
-> gecode_constraint_nroot_338(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_FloatVar(X3,Y3)
-> gecode_constraint_nroot_337(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=2))))
; throw(gecode_argument_error(nroot(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_440(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_80(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_77(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_74(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_FloatVar(X1,Y1)
-> (is_FloatVal(X2,Y2)
-> (is_Reify(X3,Y3)
-> gecode_constraint_dom_189(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))
; (is_FloatNum(X2,Y2)
-> (is_FloatNum(X3,Y3)
-> gecode_constraint_dom_186(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_FloatVarArgs(X1,Y1)
-> (is_FloatNum(X2,Y2)
-> (is_FloatNum(X3,Y3)
-> gecode_constraint_dom_172(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_BoolVarArgs(X1,Y1)
-> (is_BoolVarArgs(X2,Y2)
-> (is_IntConLevel(X3,Y3)
-> gecode_constraint_dom_170(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_BoolVar(X1,Y1)
-> (is_BoolVar(X2,Y2)
-> (is_IntConLevel(X3,Y3)
-> gecode_constraint_dom_168(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_180(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_dom_179(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))))
; (is_IntVarArgs(X2,Y2)
-> (is_IntConLevel(X3,Y3)
-> gecode_constraint_dom_177(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_175(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_IntVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_int(X3,Y3)
-> gecode_constraint_dom_197(Y0,Y1,Y2,Y3)
; (is_Reify(X3,Y3)
-> gecode_constraint_dom_201(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_dom_196(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))))
; (is_IntVar(X2,Y2)
-> (is_IntConLevel(X3,Y3)
-> gecode_constraint_dom_204(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))
; (is_IntSet(X2,Y2)
-> (is_Reify(X3,Y3)
-> gecode_constraint_dom_193(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_dom_192(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_SetVarArgs(X1,Y1)
-> (is_SetRelType(X2,Y2)
-> (is_int(X3,Y3)
-> gecode_constraint_dom_184(Y0,Y1,Y2,Y3)
; (is_IntSet(X3,Y3)
-> gecode_constraint_dom_183(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_207(Y0,Y1,Y2,Y3)
; (is_IntSet(X3,Y3)
-> gecode_constraint_dom_205(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_51(Y0,Y1,Y2)
; throw(gecode_argument_error(abs(X0,X1,X2),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> gecode_constraint_abs_50(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_68(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_63(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))).
assign(X0,X1,X2,X3,X4) :-
(is_Space_or_Clause(X0,Y0)
-> (is_FloatVarArgs(X1,Y1)
-> (is_FloatAssign(X2,Y2)
-> (is_FloatBranchFilter(X3,Y3)
-> (is_FloatVarValPrint(X4,Y4)
-> gecode_constraint_assign_8(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> (is_BoolBranchFilter(X3,Y3)
-> (is_BoolVarValPrint(X4,Y4)
-> gecode_constraint_assign_5(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> (is_IntBranchFilter(X3,Y3)
-> (is_IntVarValPrint(X4,Y4)
-> gecode_constraint_assign_11(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=3)))
; (is_SetVarArgs(X1,Y1)
-> (is_SetAssign(X2,Y2)
-> (is_SetBranchFilter(X3,Y3)
-> (is_SetVarValPrint(X4,Y4)
-> gecode_constraint_assign_14(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=3)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=2))))))
; throw(gecode_argument_error(assign(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_399(Y0,Y1,Y2)
; throw(gecode_argument_error(rel(X0,X1,X2),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> gecode_constraint_rel_389(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_356(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_FloatVar(X1,Y1)
-> (is_FloatValBranch(X2,Y2)
-> (is_FloatVarValPrint(X3,Y3)
-> gecode_constraint_branch_45(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_FloatVarArgs(X1,Y1)
-> (is_FloatVarBranch(X2,Y2)
-> (is_FloatValBranch(X3,Y3)
-> gecode_constraint_branch_29(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_23(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_BoolVar(X1,Y1)
-> (is_IntValBranch(X2,Y2)
-> (is_BoolVarValPrint(X3,Y3)
-> gecode_constraint_branch_22(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_IntVarArgs(X1,Y1)
-> (is_IntVarBranch(X2,Y2)
-> (is_IntValBranch(X3,Y3)
-> gecode_constraint_branch_35(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_IntVar(X1,Y1)
-> (is_IntValBranch(X2,Y2)
-> (is_IntVarValPrint(X3,Y3)
-> gecode_constraint_branch_47(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_41(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_SetVar(X1,Y1)
-> (is_SetValBranch(X2,Y2)
-> (is_SetVarValPrint(X3,Y3)
-> gecode_constraint_branch_49(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_326(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_81(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_78(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_75(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_88(Y0,Y1,Y2,Y3,Y4)
; (is_BoolVar(X4,Y4)
-> gecode_constraint_clause_86(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_368(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_365(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_364(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_69(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_126(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; (is_IntConLevel(X6,Y6)
-> gecode_constraint_cumulative_129(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_122(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; (is_IntConLevel(X6,Y6)
-> gecode_constraint_cumulative_125(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_119(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_138(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; (is_IntConLevel(X6,Y6)
-> gecode_constraint_cumulative_141(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_134(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; (is_IntConLevel(X6,Y6)
-> gecode_constraint_cumulative_137(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_131(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_161(Y0,Y1,Y2)
; throw(gecode_argument_error(distinct(X0,X1,X2),arg=3)))
; (is_IntArgs(X1,Y1)
-> (is_IntVarArgs(X2,Y2)
-> gecode_constraint_distinct_158(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_Reify(X3,Y3)
-> (is_IntConLevel(X4,Y4)
-> gecode_constraint_member_313(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_Reify(X3,Y3)
-> (is_IntConLevel(X4,Y4)
-> gecode_constraint_member_309(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_322(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_444(Y0,Y1,Y2)
; throw(gecode_argument_error(sqr(X0,X1,X2),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> gecode_constraint_sqr_443(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_436(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_434(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_354(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_351(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_348(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_166(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_441(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))).
extensional(X0,X1,X2,X3) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_TupleSet(X2,Y2)
-> (is_ExtensionalPropKind(X3,Y3)
-> gecode_constraint_extensional_252(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=4)))
; (is_DFA(X2,Y2)
-> (is_IntConLevel(X3,Y3)
-> gecode_constraint_extensional_255(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=3))))
; (is_BoolVarArgs(X1,Y1)
-> (is_TupleSet(X2,Y2)
-> (is_ExtensionalPropKind(X3,Y3)
-> gecode_constraint_extensional_247(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=4)))
; (is_DFA(X2,Y2)
-> (is_IntConLevel(X3,Y3)
-> gecode_constraint_extensional_250(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=3))))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=2))))
; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=1))).
circuit(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_int(X1,Y1)
-> (is_IntVarArgs(X2,Y2)
-> gecode_constraint_circuit_84(Y0,Y1,Y2)
; throw(gecode_argument_error(circuit(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntConLevel(X2,Y2)
-> gecode_constraint_circuit_83(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_FloatVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> gecode_constraint_channel_71(Y0,Y1,Y2)
; throw(gecode_argument_error(channel(X0,X1,X2),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
-> gecode_constraint_channel_61(Y0,Y1,Y2)
; (is_SetVar(X2,Y2)
-> gecode_constraint_channel_64(Y0,Y1,Y2)
; throw(gecode_argument_error(channel(X0,X1,X2),arg=3))))
; (is_BoolVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> gecode_constraint_channel_59(Y0,Y1,Y2)
; throw(gecode_argument_error(channel(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_SetVarArgs(X2,Y2)
-> gecode_constraint_channel_67(Y0,Y1,Y2)
; (is_IntVarArgs(X2,Y2)
-> gecode_constraint_channel_65(Y0,Y1,Y2)
; throw(gecode_argument_error(channel(X0,X1,X2),arg=3))))
; (is_IntVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> gecode_constraint_channel_72(Y0,Y1,Y2)
; throw(gecode_argument_error(channel(X0,X1,X2),arg=3)))
; (is_SetVarArgs(X1,Y1)
-> (is_SetVarArgs(X2,Y2)
-> gecode_constraint_channel_70(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_92(Y0,Y1,Y2,Y3,Y4)
; (is_IntVar(X4,Y4)
-> gecode_constraint_count_94(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_110(Y0,Y1,Y2,Y3,Y4)
; (is_IntVar(X4,Y4)
-> gecode_constraint_count_112(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_102(Y0,Y1,Y2,Y3,Y4)
; (is_IntVar(X4,Y4)
-> gecode_constraint_count_104(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_101(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_97(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_107(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_114(Y0,Y1,Y2,Y3,Y4)
; (is_IntVar(X4,Y4)
-> gecode_constraint_count_116(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_156(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_154(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_152(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_150(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_148(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_146(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_144(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_142(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_55(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))).
extensional(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_TupleSet(X2,Y2)
-> gecode_constraint_extensional_251(Y0,Y1,Y2)
; (is_DFA(X2,Y2)
-> gecode_constraint_extensional_254(Y0,Y1,Y2)
; throw(gecode_argument_error(extensional(X0,X1,X2),arg=3))))
; (is_BoolVarArgs(X1,Y1)
-> (is_TupleSet(X2,Y2)
-> gecode_constraint_extensional_246(Y0,Y1,Y2)
; (is_DFA(X2,Y2)
-> gecode_constraint_extensional_249(Y0,Y1,Y2)
; throw(gecode_argument_error(extensional(X0,X1,X2),arg=3))))
; throw(gecode_argument_error(extensional(X0,X1,X2),arg=2))))
; throw(gecode_argument_error(extensional(X0,X1,X2),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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_linear_293(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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_linear_297(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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_linear_261(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_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_linear_265(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_FloatValArgs(X1,Y1)
-> (is_FloatVarArgs(X2,Y2)
-> (is_FloatRelType(X3,Y3)
-> (is_FloatVar(X4,Y4)
-> (is_Reify(X5,Y5)
-> gecode_constraint_linear_269(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))
; (is_FloatNum(X4,Y4)
-> (is_Reify(X5,Y5)
-> gecode_constraint_linear_267(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_Reify(X5,Y5)
-> gecode_constraint_linear_284(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
-> gecode_constraint_linear_283(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))))
; (is_IntVar(X4,Y4)
-> (is_Reify(X5,Y5)
-> gecode_constraint_linear_288(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
-> gecode_constraint_linear_287(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_Reify(X5,Y5)
-> gecode_constraint_linear_276(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
-> gecode_constraint_linear_275(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))))
; (is_IntVar(X4,Y4)
-> (is_Reify(X5,Y5)
-> gecode_constraint_linear_280(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
-> gecode_constraint_linear_279(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_333(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_328(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_164(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_445(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_355(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_352(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_349(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_457(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_unary_460(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_453(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_unary_456(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_450(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_439(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_sorted_442(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_223(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_217(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_235(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_233(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))).
assign(X0,X1,X2,X3) :-
(is_Space_or_Clause(X0,Y0)
-> (is_FloatVar(X1,Y1)
-> (is_FloatAssign(X2,Y2)
-> (is_FloatVarValPrint(X3,Y3)
-> gecode_constraint_assign_16(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3)))
; (is_FloatVarArgs(X1,Y1)
-> (is_FloatAssign(X2,Y2)
-> (is_FloatBranchFilter(X3,Y3)
-> gecode_constraint_assign_7(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> (is_BoolBranchFilter(X3,Y3)
-> gecode_constraint_assign_4(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3)))
; (is_BoolVar(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> (is_BoolVarValPrint(X3,Y3)
-> gecode_constraint_assign_2(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> (is_IntBranchFilter(X3,Y3)
-> gecode_constraint_assign_10(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3)))
; (is_IntVar(X1,Y1)
-> (is_IntAssign(X2,Y2)
-> (is_IntVarValPrint(X3,Y3)
-> gecode_constraint_assign_18(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3)))
; (is_SetVarArgs(X1,Y1)
-> (is_SetAssign(X2,Y2)
-> (is_SetBranchFilter(X3,Y3)
-> gecode_constraint_assign_13(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_SetAssign(X2,Y2)
-> (is_SetVarValPrint(X3,Y3)
-> gecode_constraint_assign_20(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=2))))))))))
; throw(gecode_argument_error(assign(X0,X1,X2,X3),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_221(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_225(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_215(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_213(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_244(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_242(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_240(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_238(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_231(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_237(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_229(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_438(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))).
branch(X0,X1,X2,X3,X4) :-
(is_Space_or_Clause(X0,Y0)
-> (is_FloatVarArgs(X1,Y1)
-> (is_FloatVarBranch(X2,Y2)
-> (is_FloatValBranch(X3,Y3)
-> (is_FloatBranchFilter(X4,Y4)
-> gecode_constraint_branch_30(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntVarBranch(X2,Y2)
-> (is_IntValBranch(X3,Y3)
-> (is_Symmetries(X4,Y4)
-> gecode_constraint_branch_26(Y0,Y1,Y2,Y3,Y4)
; (is_BoolBranchFilter(X4,Y4)
-> gecode_constraint_branch_24(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVarBranch(X2,Y2)
-> (is_IntValBranch(X3,Y3)
-> (is_Symmetries(X4,Y4)
-> gecode_constraint_branch_32(Y0,Y1,Y2,Y3,Y4)
; (is_IntBranchFilter(X4,Y4)
-> gecode_constraint_branch_36(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=3)))
; (is_SetVarArgs(X1,Y1)
-> (is_SetVarBranch(X2,Y2)
-> (is_SetValBranch(X3,Y3)
-> (is_SetBranchFilter(X4,Y4)
-> gecode_constraint_branch_42(Y0,Y1,Y2,Y3,Y4)
; (is_Symmetries(X4,Y4)
-> gecode_constraint_branch_38(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=3)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=2))))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),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_79(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))).
pow(X0,X1,X2,X3) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_IntVar(X3,Y3)
-> gecode_constraint_pow_361(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_FloatVar(X3,Y3)
-> gecode_constraint_pow_360(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=2))))
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=1))).
precede(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_SetVarArgs(X1,Y1)
-> (is_IntArgs(X2,Y2)
-> gecode_constraint_precede_367(Y0,Y1,Y2)
; throw(gecode_argument_error(precede(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntArgs(X2,Y2)
-> gecode_constraint_precede_363(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_128(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_124(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_118(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
-> gecode_constraint_cumulative_121(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_140(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_136(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_130(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
-> gecode_constraint_cumulative_133(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_159(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_FloatVarArgs(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> gecode_constraint_min_314(Y0,Y1,Y2)
; throw(gecode_argument_error(min(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
-> gecode_constraint_min_315(Y0,Y1,Y2)
; throw(gecode_argument_error(min(X0,X1,X2),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> gecode_constraint_min_320(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_448(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_435(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_433(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_464(Y0,Y1,Y2)
; throw(gecode_argument_error(unshare(X0,X1,X2),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntConLevel(X2,Y2)
-> gecode_constraint_unshare_462(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_359(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_350(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_165(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))).
branch(X0,X1,X2,X3,X4,X5) :-
(is_Space_or_Clause(X0,Y0)
-> (is_FloatVarArgs(X1,Y1)
-> (is_FloatVarBranch(X2,Y2)
-> (is_FloatValBranch(X3,Y3)
-> (is_FloatBranchFilter(X4,Y4)
-> (is_FloatVarValPrint(X5,Y5)
-> gecode_constraint_branch_31(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntVarBranch(X2,Y2)
-> (is_IntValBranch(X3,Y3)
-> (is_Symmetries(X4,Y4)
-> (is_BoolBranchFilter(X5,Y5)
-> gecode_constraint_branch_27(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6)))
; (is_BoolBranchFilter(X4,Y4)
-> (is_BoolVarValPrint(X5,Y5)
-> gecode_constraint_branch_25(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=5))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVarBranch(X2,Y2)
-> (is_IntValBranch(X3,Y3)
-> (is_Symmetries(X4,Y4)
-> (is_IntBranchFilter(X5,Y5)
-> gecode_constraint_branch_33(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6)))
; (is_IntBranchFilter(X4,Y4)
-> (is_IntVarValPrint(X5,Y5)
-> gecode_constraint_branch_37(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=5))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=3)))
; (is_SetVarArgs(X1,Y1)
-> (is_SetVarBranch(X2,Y2)
-> (is_SetValBranch(X3,Y3)
-> (is_SetBranchFilter(X4,Y4)
-> (is_SetVarValPrint(X5,Y5)
-> gecode_constraint_branch_43(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6)))
; (is_Symmetries(X4,Y4)
-> (is_SetBranchFilter(X5,Y5)
-> gecode_constraint_branch_39(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=5))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=4)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=3)))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=2))))))
; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),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_332(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_120(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_132(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_310(Y0,Y1,Y2)
; throw(gecode_argument_error(member(X0,X1,X2),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_BoolVar(X2,Y2)
-> gecode_constraint_member_306(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_111(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_113(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_115(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_117(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_103(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_105(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_93(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_95(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))).
pow(X0,X1,X2,X3,X4) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
-> gecode_constraint_pow_362(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=3)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=2)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=1))).
notMin(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> gecode_constraint_notMin_336(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_127(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_123(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_139(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_135(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_46(Y0,Y1,Y2)
; throw(gecode_argument_error(branch(X0,X1,X2),arg=3)))
; (is_BoolVar(X1,Y1)
-> (is_IntValBranch(X2,Y2)
-> gecode_constraint_branch_21(Y0,Y1,Y2)
; throw(gecode_argument_error(branch(X0,X1,X2),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatValBranch(X2,Y2)
-> gecode_constraint_branch_44(Y0,Y1,Y2)
; throw(gecode_argument_error(branch(X0,X1,X2),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_SetValBranch(X2,Y2)
-> gecode_constraint_branch_48(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_FloatVar(X1,Y1)
-> (is_FloatVal(X2,Y2)
-> gecode_constraint_dom_188(Y0,Y1,Y2)
; (is_FloatVar(X2,Y2)
-> gecode_constraint_dom_190(Y0,Y1,Y2)
; throw(gecode_argument_error(dom(X0,X1,X2),arg=3))))
; (is_FloatVarArgs(X1,Y1)
-> (is_FloatVarArgs(X2,Y2)
-> gecode_constraint_dom_171(Y0,Y1,Y2)
; (is_FloatVal(X2,Y2)
-> gecode_constraint_dom_173(Y0,Y1,Y2)
; throw(gecode_argument_error(dom(X0,X1,X2),arg=3))))
; (is_BoolVarArgs(X1,Y1)
-> (is_BoolVarArgs(X2,Y2)
-> gecode_constraint_dom_169(Y0,Y1,Y2)
; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))
; (is_BoolVar(X1,Y1)
-> (is_BoolVar(X2,Y2)
-> gecode_constraint_dom_167(Y0,Y1,Y2)
; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_int(X2,Y2)
-> gecode_constraint_dom_178(Y0,Y1,Y2)
; (is_IntVarArgs(X2,Y2)
-> gecode_constraint_dom_176(Y0,Y1,Y2)
; (is_IntSet(X2,Y2)
-> gecode_constraint_dom_174(Y0,Y1,Y2)
; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))))
; (is_IntVar(X1,Y1)
-> (is_int(X2,Y2)
-> gecode_constraint_dom_195(Y0,Y1,Y2)
; (is_IntVar(X2,Y2)
-> gecode_constraint_dom_203(Y0,Y1,Y2)
; (is_IntSet(X2,Y2)
-> gecode_constraint_dom_191(Y0,Y1,Y2)
; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))))
; (is_SetVarArgs(X1,Y1)
-> (is_SetVarArgs(X2,Y2)
-> gecode_constraint_dom_182(Y0,Y1,Y2)
; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_SetVar(X2,Y2)
-> gecode_constraint_dom_211(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_Reify(X4,Y4)
-> gecode_constraint_linear_292(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_linear_291(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_linear_296(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_linear_295(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_FloatVarArgs(X1,Y1)
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_linear_273(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))
; (is_FloatNum(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_linear_271(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_Reify(X4,Y4)
-> gecode_constraint_linear_260(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_linear_259(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> gecode_constraint_linear_264(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
-> gecode_constraint_linear_263(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_FloatValArgs(X1,Y1)
-> (is_FloatVarArgs(X2,Y2)
-> (is_FloatRelType(X3,Y3)
-> (is_FloatVar(X4,Y4)
-> gecode_constraint_linear_268(Y0,Y1,Y2,Y3,Y4)
; (is_FloatNum(X4,Y4)
-> gecode_constraint_linear_266(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_282(Y0,Y1,Y2,Y3,Y4)
; (is_IntVar(X4,Y4)
-> gecode_constraint_linear_286(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_274(Y0,Y1,Y2,Y3,Y4)
; (is_IntVar(X4,Y4)
-> gecode_constraint_linear_278(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_327(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
-> gecode_constraint_nooverlap_330(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_245(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_243(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_241(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_239(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_FloatVar(X1,Y1)
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVal(X3,Y3)
-> gecode_constraint_rel_405(Y0,Y1,Y2,Y3)
; (is_FloatVar(X3,Y3)
-> gecode_constraint_rel_407(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_423(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_421(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_FloatVarArgs(X1,Y1)
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVal(X3,Y3)
-> gecode_constraint_rel_393(Y0,Y1,Y2,Y3)
; (is_FloatVar(X3,Y3)
-> gecode_constraint_rel_394(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_391(Y0,Y1,Y2,Y3)
; (is_BoolVarArgs(X3,Y3)
-> gecode_constraint_rel_387(Y0,Y1,Y2,Y3)
; (is_BoolVar(X3,Y3)
-> gecode_constraint_rel_385(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_rel_390(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_BoolVar(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> gecode_constraint_rel_381(Y0,Y1,Y2,Y3)
; (is_BoolVar(X3,Y3)
-> gecode_constraint_rel_377(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_401(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
-> gecode_constraint_rel_403(Y0,Y1,Y2,Y3)
; (is_IntVarArgs(X3,Y3)
-> gecode_constraint_rel_397(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
-> gecode_constraint_rel_400(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_409(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
-> gecode_constraint_rel_413(Y0,Y1,Y2,Y3)
; (is_SetVar(X3,Y3)
-> gecode_constraint_rel_417(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_418(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_424(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_429(Y0,Y1,Y2,Y3)
; (is_SetVar(X3,Y3)
-> gecode_constraint_rel_431(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_371(Y0,Y1,Y2,Y3)
; (is_BoolVar(X3,Y3)
-> gecode_constraint_rel_369(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_319(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_108(Y0,Y1,Y2)
; (is_IntSetArgs(X2,Y2)
-> gecode_constraint_count_98(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))).
ite(X0,X1,X2,X3,X4,X5) :-
(is_Space_or_Clause(X0,Y0)
-> (is_BoolVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntVar(X4,Y4)
-> (is_IntConLevel(X5,Y5)
-> gecode_constraint_ite_257(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=4)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=3)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=2)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=1))).
Reference in New Issue Copy Permalink