generic-match.cc

Bug Summary

File:	objdir/gcc/generic-match.cc
Warning:	line 89869, column 7 Value stored to 'stype' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name generic-match.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -Wno-unused -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-vHrDru.plist -x c++ generic-match.cc

1	/* Generated automatically by the program `genmatch' from
2	a IL pattern matching and simplification description. */
3
4	#include "generic-match-head.cc"
5
6	bool
7	tree_nop_convert (tree t, tree *res_ops)
8	{
9	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 9, __FUNCTION__))->typed.type);
10	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 10, __FUNCTION__)) ->base.side_effects_flag)) return false;
11	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
12	{
13	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
14	{
15	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 15, __FUNCTION__)))));
16	{
17	/* #line 148 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
18	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
19	/* #line 148 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
20	if (tree_nop_conversion_p (type, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 20, __FUNCTION__))->typed.type))
21	)
22	{
23	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 146, __FILE__"generic-match.cc", __LINE__23);
24	{
25	res_ops[0] = captures[0];
26	return true;
27	}
28	next_after_fail1:;
29	}
30	}
31	break;
32	}
33	case VIEW_CONVERT_EXPR:
34	{
35	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 35, __FUNCTION__)))));
36	{
37	/* #line 151 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
38	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
39	/* #line 151 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
40	if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE) && VECTOR_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 40, __FUNCTION__))->typed.type ))->base.code) == VECTOR_TYPE)
41	&& known_eq (TYPE_VECTOR_SUBPARTS (type),(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 42, __FUNCTION__))->typed.type))))
42	TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[0])))(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 42, __FUNCTION__))->typed.type))))
43	&& tree_nop_conversion_p (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "generic-match.cc" , 43, __FUNCTION__))->typed.type), TREE_TYPE (TREE_TYPE (captures[0]))((contains_struct_check ((((contains_struct_check ((captures[ 0]), (TS_TYPED), "generic-match.cc", 43, __FUNCTION__))->typed .type)), (TS_TYPED), "generic-match.cc", 43, __FUNCTION__))-> typed.type))
44	)
45	{
46	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 149, __FILE__"generic-match.cc", __LINE__46);
47	{
48	res_ops[0] = captures[0];
49	return true;
50	}
51	next_after_fail2:;
52	}
53	}
54	break;
55	}
56	default:;
57	}
58	return false;
59	}
60
61	bool
62	tree_power_of_two_cand (tree t, tree *res_ops)
63	{
64	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 64, __FUNCTION__))->typed.type);
65	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 65, __FUNCTION__)) ->base.side_effects_flag)) return false;
66	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
67	{
68	case INTEGER_CST:
69	{
70	{
71	/* #line 796 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
72	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
73	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 796, __FILE__"generic-match.cc", __LINE__73);
74	{
75	res_ops[0] = captures[0];
76	return true;
77	}
78	next_after_fail3:;
79	}
80	break;
81	}
82	case LSHIFT_EXPR:
83	{
84	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 84, __FUNCTION__)))));
85	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 85, __FUNCTION__)))));
86	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
87	{
88	case INTEGER_CST:
89	{
90	{
91	/* #line 798 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
92	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
93	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 798, __FILE__"generic-match.cc", __LINE__93);
94	{
95	res_ops[0] = captures[0];
96	return true;
97	}
98	next_after_fail4:;
99	}
100	break;
101	}
102	default:;
103	}
104	break;
105	}
106	default:;
107	}
108	return false;
109	}
110
111	bool
112	tree_negate_expr_p (tree t)
113	{
114	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 114, __FUNCTION__))->typed.type);
115	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 115, __FUNCTION__) )->base.side_effects_flag)) return false;
116	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
117	{
118	case INTEGER_CST:
119	{
120	{
121	/* #line 1678 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
122	/* #line 1678 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
123	if ((INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
124	&& TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 124 , __FUNCTION__))->base.u.bits.unsigned_flag))
125	\|\| (!TYPE_OVERFLOW_SANITIZED (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ( (enum tree_code) (type)->base.code) == INTEGER_TYPE) && !((((enum tree_code) (type)->base.code) == POINTER_TYPE \|\| ((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.cc", 125, __FUNCTION__))->base.u. bits.unsigned_flag \|\| global_options.x_flag_wrapv)) && (global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
126	&& may_negate_without_overflow_p (t))
127	)
128	{
129	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1677, __FILE__"generic-match.cc", __LINE__129);
130	{
131	return true;
132	}
133	next_after_fail5:;
134	}
135	}
136	break;
137	}
138	case FIXED_CST:
139	{
140	{
141	/* #line 1683 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
142	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1683, __FILE__"generic-match.cc", __LINE__142);
143	{
144	return true;
145	}
146	next_after_fail6:;
147	}
148	break;
149	}
150	case NEGATE_EXPR:
151	{
152	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 152, __FUNCTION__)))));
153	{
154	/* #line 1686 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
155	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
156	/* #line 1686 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
157	if (!TYPE_OVERFLOW_SANITIZED (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ( (enum tree_code) (type)->base.code) == INTEGER_TYPE) && !((((enum tree_code) (type)->base.code) == POINTER_TYPE \|\| ((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.cc", 157, __FUNCTION__))->base.u. bits.unsigned_flag \|\| global_options.x_flag_wrapv)) && (global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
158	)
159	{
160	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1685, __FILE__"generic-match.cc", __LINE__160);
161	{
162	return true;
163	}
164	next_after_fail7:;
165	}
166	}
167	break;
168	}
169	case REAL_CST:
170	{
171	{
172	/* #line 1689 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
173	/* #line 1689 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
174	if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (t))real_isneg (&((*(&(tree_check ((t), "generic-match.cc" , 174, __FUNCTION__, (REAL_CST)))->real_cst.value))))
175	)
176	{
177	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1688, __FILE__"generic-match.cc", __LINE__177);
178	{
179	return true;
180	}
181	next_after_fail8:;
182	}
183	}
184	break;
185	}
186	case VECTOR_CST:
187	{
188	{
189	/* #line 1694 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
190	/* #line 1694 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
191	if (FLOAT_TYPE_P (TREE_TYPE (type))((((enum tree_code) (((contains_struct_check ((type), (TS_TYPED ), "generic-match.cc", 191, __FUNCTION__))->typed.type))-> base.code) == REAL_TYPE) \|\| ((((enum tree_code) (((contains_struct_check ((type), (TS_TYPED), "generic-match.cc", 191, __FUNCTION__)) ->typed.type))->base.code) == COMPLEX_TYPE \|\| (((enum tree_code ) (((contains_struct_check ((type), (TS_TYPED), "generic-match.cc" , 191, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE )) && (((enum tree_code) (((contains_struct_check ((( (contains_struct_check ((type), (TS_TYPED), "generic-match.cc" , 191, __FUNCTION__))->typed.type)), (TS_TYPED), "generic-match.cc" , 191, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE ))) \|\| TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE \|\| ( (enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options .x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.cc" , 191, __FUNCTION__))->base.u.bits.unsigned_flag \|\| global_options .x_flag_wrapv))
192	)
193	{
194	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1693, __FILE__"generic-match.cc", __LINE__194);
195	{
196	return true;
197	}
198	next_after_fail9:;
199	}
200	}
201	break;
202	}
203	case MINUS_EXPR:
204	{
205	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 205, __FUNCTION__)))));
206	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 206, __FUNCTION__)))));
207	{
208	/* #line 1697 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
209	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
210	/* #line 1697 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
211	if ((ANY_INTEGRAL_TYPE_P (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ( (enum tree_code) (type)->base.code) == INTEGER_TYPE) \|\| (( ((enum tree_code) (type)->base.code) == COMPLEX_TYPE \|\| (( (enum tree_code) (type)->base.code) == VECTOR_TYPE)) && (((enum tree_code) (((contains_struct_check ((type), (TS_TYPED ), "generic-match.cc", 211, __FUNCTION__))->typed.type))-> base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (((contains_struct_check ((type), (TS_TYPED), "generic-match.cc", 211, __FUNCTION__)) ->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code ) (((contains_struct_check ((type), (TS_TYPED), "generic-match.cc" , 211, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE ))) && TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE \|\| ( (enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options .x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.cc" , 211, __FUNCTION__))->base.u.bits.unsigned_flag \|\| global_options .x_flag_wrapv)))
212	\|\| (FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) \|\| (( ((enum tree_code) (type)->base.code) == COMPLEX_TYPE \|\| (( (enum tree_code) (type)->base.code) == VECTOR_TYPE)) && (((enum tree_code) (((contains_struct_check ((type), (TS_TYPED ), "generic-match.cc", 212, __FUNCTION__))->typed.type))-> base.code) == REAL_TYPE)))
213	&& !HONOR_SIGN_DEPENDENT_ROUNDING (type)
214	&& !HONOR_SIGNED_ZEROS (type))
215	)
216	{
217	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1696, __FILE__"generic-match.cc", __LINE__217);
218	{
219	return true;
220	}
221	next_after_fail10:;
222	}
223	}
224	break;
225	}
226	default:;
227	}
228	return false;
229	}
230
231	bool
232	tree_truth_valued_p (tree t)
233	{
234	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 234, __FUNCTION__))->typed.type);
235	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 235, __FUNCTION__) )->base.side_effects_flag)) return false;
236	{
237	/* #line 1885 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
238	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
239	/* #line 1885 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
240	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE) && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 240 , __FUNCTION__))->type_common.precision) == 1
241	)
242	{
243	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1884, __FILE__"generic-match.cc", __LINE__243);
244	{
245	return true;
246	}
247	next_after_fail11:;
248	}
249	}
250	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
251	{
252	case LT_EXPR:
253	{
254	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 254, __FUNCTION__)))));
255	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 255, __FUNCTION__)))));
256	{
257	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
258	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
259	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__259);
260	{
261	return true;
262	}
263	next_after_fail12:;
264	}
265	break;
266	}
267	case LE_EXPR:
268	{
269	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 269, __FUNCTION__)))));
270	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 270, __FUNCTION__)))));
271	{
272	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
273	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
274	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__274);
275	{
276	return true;
277	}
278	next_after_fail13:;
279	}
280	break;
281	}
282	case EQ_EXPR:
283	{
284	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 284, __FUNCTION__)))));
285	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 285, __FUNCTION__)))));
286	{
287	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
288	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
289	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__289);
290	{
291	return true;
292	}
293	next_after_fail14:;
294	}
295	break;
296	}
297	case NE_EXPR:
298	{
299	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 299, __FUNCTION__)))));
300	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 300, __FUNCTION__)))));
301	{
302	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
303	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
304	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__304);
305	{
306	return true;
307	}
308	next_after_fail15:;
309	}
310	break;
311	}
312	case GE_EXPR:
313	{
314	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 314, __FUNCTION__)))));
315	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 315, __FUNCTION__)))));
316	{
317	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
318	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
319	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__319);
320	{
321	return true;
322	}
323	next_after_fail16:;
324	}
325	break;
326	}
327	case GT_EXPR:
328	{
329	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 329, __FUNCTION__)))));
330	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 330, __FUNCTION__)))));
331	{
332	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
333	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
334	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__334);
335	{
336	return true;
337	}
338	next_after_fail17:;
339	}
340	break;
341	}
342	case UNORDERED_EXPR:
343	{
344	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 344, __FUNCTION__)))));
345	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 345, __FUNCTION__)))));
346	{
347	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
348	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
349	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__349);
350	{
351	return true;
352	}
353	next_after_fail18:;
354	}
355	break;
356	}
357	case ORDERED_EXPR:
358	{
359	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 359, __FUNCTION__)))));
360	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 360, __FUNCTION__)))));
361	{
362	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
363	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
364	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__364);
365	{
366	return true;
367	}
368	next_after_fail19:;
369	}
370	break;
371	}
372	case UNLT_EXPR:
373	{
374	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 374, __FUNCTION__)))));
375	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 375, __FUNCTION__)))));
376	{
377	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
378	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
379	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__379);
380	{
381	return true;
382	}
383	next_after_fail20:;
384	}
385	break;
386	}
387	case UNLE_EXPR:
388	{
389	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 389, __FUNCTION__)))));
390	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 390, __FUNCTION__)))));
391	{
392	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
393	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
394	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__394);
395	{
396	return true;
397	}
398	next_after_fail21:;
399	}
400	break;
401	}
402	case UNGT_EXPR:
403	{
404	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 404, __FUNCTION__)))));
405	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 405, __FUNCTION__)))));
406	{
407	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
408	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
409	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__409);
410	{
411	return true;
412	}
413	next_after_fail22:;
414	}
415	break;
416	}
417	case UNGE_EXPR:
418	{
419	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 419, __FUNCTION__)))));
420	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 420, __FUNCTION__)))));
421	{
422	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
423	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
424	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__424);
425	{
426	return true;
427	}
428	next_after_fail23:;
429	}
430	break;
431	}
432	case UNEQ_EXPR:
433	{
434	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 434, __FUNCTION__)))));
435	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 435, __FUNCTION__)))));
436	{
437	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
438	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
439	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__439);
440	{
441	return true;
442	}
443	next_after_fail24:;
444	}
445	break;
446	}
447	case LTGT_EXPR:
448	{
449	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 449, __FUNCTION__)))));
450	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 450, __FUNCTION__)))));
451	{
452	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
453	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
454	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__454);
455	{
456	return true;
457	}
458	next_after_fail25:;
459	}
460	break;
461	}
462	case TRUTH_AND_EXPR:
463	{
464	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 464, __FUNCTION__)))));
465	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 465, __FUNCTION__)))));
466	{
467	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
468	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
469	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__469);
470	{
471	return true;
472	}
473	next_after_fail26:;
474	}
475	break;
476	}
477	case TRUTH_ANDIF_EXPR:
478	{
479	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 479, __FUNCTION__)))));
480	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 480, __FUNCTION__)))));
481	{
482	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
483	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
484	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__484);
485	{
486	return true;
487	}
488	next_after_fail27:;
489	}
490	break;
491	}
492	case TRUTH_OR_EXPR:
493	{
494	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 494, __FUNCTION__)))));
495	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 495, __FUNCTION__)))));
496	{
497	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
498	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
499	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__499);
500	{
501	return true;
502	}
503	next_after_fail28:;
504	}
505	break;
506	}
507	case TRUTH_ORIF_EXPR:
508	{
509	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 509, __FUNCTION__)))));
510	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 510, __FUNCTION__)))));
511	{
512	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
513	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
514	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__514);
515	{
516	return true;
517	}
518	next_after_fail29:;
519	}
520	break;
521	}
522	case TRUTH_XOR_EXPR:
523	{
524	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 524, __FUNCTION__)))));
525	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 525, __FUNCTION__)))));
526	{
527	/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
528	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
529	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__529);
530	{
531	return true;
532	}
533	next_after_fail30:;
534	}
535	break;
536	}
537	case TRUTH_NOT_EXPR:
538	{
539	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 539, __FUNCTION__)))));
540	{
541	/* #line 1890 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
542	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
543	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1890, __FILE__"generic-match.cc", __LINE__543);
544	{
545	return true;
546	}
547	next_after_fail31:;
548	}
549	break;
550	}
551	default:;
552	}
553	return false;
554	}
555
556	bool
557	tree_logical_inverted_value (tree t, tree *res_ops)
558	{
559	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 559, __FUNCTION__))->typed.type);
560	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 560, __FUNCTION__) )->base.side_effects_flag)) return false;
561	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
562	{
563	case TRUTH_NOT_EXPR:
564	{
565	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 565, __FUNCTION__)))));
566	{
567	/* #line 1892 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
568	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
569	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1892, __FILE__"generic-match.cc", __LINE__569);
570	{
571	res_ops[0] = captures[0];
572	return true;
573	}
574	next_after_fail32:;
575	}
576	break;
577	}
578	case BIT_NOT_EXPR:
579	{
580	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 580, __FUNCTION__)))));
581	if (tree_truth_valued_p (_p0))
582	{
583	{
584	/* #line 1894 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
585	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
586	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1894, __FILE__"generic-match.cc", __LINE__586);
587	{
588	res_ops[0] = captures[0];
589	return true;
590	}
591	next_after_fail33:;
592	}
593	}
594	break;
595	}
596	case EQ_EXPR:
597	{
598	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 598, __FUNCTION__)))));
599	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 599, __FUNCTION__)))));
600	if (integer_zerop (_p1))
601	{
602	{
603	/* #line 1896 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
604	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
605	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1896, __FILE__"generic-match.cc", __LINE__605);
606	{
607	res_ops[0] = captures[0];
608	return true;
609	}
610	next_after_fail34:;
611	}
612	}
613	break;
614	}
615	case NE_EXPR:
616	{
617	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 617, __FUNCTION__)))));
618	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 618, __FUNCTION__)))));
619	if (tree_truth_valued_p (_p0))
620	{
621	if (integer_truep (_p1))
622	{
623	{
624	/* #line 1898 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
625	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
626	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1898, __FILE__"generic-match.cc", __LINE__626);
627	{
628	res_ops[0] = captures[0];
629	return true;
630	}
631	next_after_fail35:;
632	}
633	}
634	}
635	break;
636	}
637	case BIT_XOR_EXPR:
638	{
639	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 639, __FUNCTION__)))));
640	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 640, __FUNCTION__)))));
641	if (tree_truth_valued_p (_p0))
642	{
643	if (integer_truep (_p1))
644	{
645	{
646	/* #line 1900 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
647	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
648	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1900, __FILE__"generic-match.cc", __LINE__648);
649	{
650	res_ops[0] = captures[0];
651	return true;
652	}
653	next_after_fail36:;
654	}
655	}
656	}
657	break;
658	}
659	default:;
660	}
661	return false;
662	}
663
664	bool
665	tree_zero_one_valued_p (tree t)
666	{
667	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 667, __FUNCTION__))->typed.type);
668	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 668, __FUNCTION__) )->base.side_effects_flag)) return false;
669	{
670	/* #line 1925 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
671	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
672	/* #line 1925 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
673	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE) && tree_nonzero_bits (captures[0]) == 1
674	)
675	{
676	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1924, __FILE__"generic-match.cc", __LINE__676);
677	{
678	return true;
679	}
680	next_after_fail37:;
681	}
682	}
683	if (tree_truth_valued_p (t))
684	{
685	{
686	/* #line 1927 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
687	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
688	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1927, __FILE__"generic-match.cc", __LINE__688);
689	{
690	return true;
691	}
692	next_after_fail38:;
693	}
694	}
695	return false;
696	}
697
698	bool
699	tree_with_possible_nonzero_bits (tree t)
700	{
701	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 701, __FUNCTION__))->typed.type);
702	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 702, __FUNCTION__) )->base.side_effects_flag)) return false;
703	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
704	{
705	case INTEGER_CST:
706	{
707	{
708	/* #line 2402 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
709	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
710	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2402, __FILE__"generic-match.cc", __LINE__710);
711	{
712	return true;
713	}
714	next_after_fail39:;
715	}
716	break;
717	}
718	case SSA_NAME:
719	{
720	{
721	/* #line 2405 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
722	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
723	/* #line 2405 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
724	if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 724, __FUNCTION__))->typed. type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 724, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 724, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE) \|\| POINTER_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 724, __FUNCTION__))->typed. type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) (( (contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 724, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE )
725	)
726	{
727	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2404, __FILE__"generic-match.cc", __LINE__727);
728	{
729	return true;
730	}
731	next_after_fail40:;
732	}
733	}
734	break;
735	}
736	default:;
737	}
738	return false;
739	}
740
741	bool
742	tree_with_possible_nonzero_bits2 (tree t, tree *res_ops)
743	{
744	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 744, __FUNCTION__))->typed.type);
745	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 745, __FUNCTION__) )->base.side_effects_flag)) return false;
746	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
747	{
748	case BIT_AND_EXPR:
749	{
750	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 750, __FUNCTION__)))));
751	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 751, __FUNCTION__)))));
752	if (tree_with_possible_nonzero_bits (_p0))
753	{
754	{
755	/* #line 2409 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
756	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
757	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2409, __FILE__"generic-match.cc", __LINE__757);
758	{
759	res_ops[0] = captures[0];
760	return true;
761	}
762	next_after_fail41:;
763	}
764	}
765	if (tree_with_possible_nonzero_bits (_p1))
766	{
767	{
768	/* #line 2409 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
769	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
770	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2409, __FILE__"generic-match.cc", __LINE__770);
771	{
772	res_ops[0] = captures[0];
773	return true;
774	}
775	next_after_fail42:;
776	}
777	}
778	break;
779	}
780	default:;
781	}
782	if (tree_with_possible_nonzero_bits (t))
783	{
784	{
785	/* #line 2407 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
786	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
787	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2407, __FILE__"generic-match.cc", __LINE__787);
788	{
789	res_ops[0] = captures[0];
790	return true;
791	}
792	next_after_fail43:;
793	}
794	}
795	return false;
796	}
797
798	bool
799	tree_with_certain_nonzero_bits2 (tree t, tree *res_ops)
800	{
801	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 801, __FUNCTION__))->typed.type);
802	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 802, __FUNCTION__) )->base.side_effects_flag)) return false;
803	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
804	{
805	case INTEGER_CST:
806	{
807	{
808	/* #line 2414 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
809	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
810	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2414, __FILE__"generic-match.cc", __LINE__810);
811	{
812	res_ops[0] = captures[0];
813	return true;
814	}
815	next_after_fail44:;
816	}
817	break;
818	}
819	case BIT_IOR_EXPR:
820	{
821	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 821, __FUNCTION__)))));
822	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 822, __FUNCTION__)))));
823	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
824	{
825	case INTEGER_CST:
826	{
827	{
828	/* #line 2416 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
829	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
830	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2416, __FILE__"generic-match.cc", __LINE__830);
831	{
832	res_ops[0] = captures[0];
833	return true;
834	}
835	next_after_fail45:;
836	}
837	break;
838	}
839	default:;
840	}
841	break;
842	}
843	default:;
844	}
845	return false;
846	}
847
848	bool
849	tree_min_value (tree t)
850	{
851	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 851, __FUNCTION__))->typed.type);
852	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 852, __FUNCTION__) )->base.side_effects_flag)) return false;
853	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
854	{
855	case INTEGER_CST:
856	{
857	{
858	/* #line 2585 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
859	/* #line 2585 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
860	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
861	&& wi::eq_p (wi::to_wide (t), wi::min_value (type))
862	)
863	{
864	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2584, __FILE__"generic-match.cc", __LINE__864);
865	{
866	return true;
867	}
868	next_after_fail46:;
869	}
870	}
871	break;
872	}
873	default:;
874	}
875	return false;
876	}
877
878	bool
879	tree_max_value (tree t)
880	{
881	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 881, __FUNCTION__))->typed.type);
882	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 882, __FUNCTION__) )->base.side_effects_flag)) return false;
883	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
884	{
885	case INTEGER_CST:
886	{
887	{
888	/* #line 2590 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
889	/* #line 2590 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
890	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
891	&& wi::eq_p (wi::to_wide (t), wi::max_value (type))
892	)
893	{
894	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2589, __FILE__"generic-match.cc", __LINE__894);
895	{
896	return true;
897	}
898	next_after_fail47:;
899	}
900	}
901	break;
902	}
903	default:;
904	}
905	return false;
906	}
907
908	bool
909	tree_compositional_complex (tree t)
910	{
911	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 911, __FUNCTION__))->typed.type);
912	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 912, __FUNCTION__) )->base.side_effects_flag)) return false;
913	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
914	{
915	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
916	{
917	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 917, __FUNCTION__)))));
918	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
919	{
920	case COMPLEX_EXPR:
921	{
922	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 922, __FUNCTION__)))));
923	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 923, __FUNCTION__)))));
924	{
925	/* #line 4271 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
926	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q21 };
927	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4271, __FILE__"generic-match.cc", __LINE__927);
928	{
929	return true;
930	}
931	next_after_fail48:;
932	}
933	break;
934	}
935	default:;
936	}
937	break;
938	}
939	case COMPLEX_EXPR:
940	{
941	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 941, __FUNCTION__)))));
942	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 942, __FUNCTION__)))));
943	{
944	/* #line 4271 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
945	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
946	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4271, __FILE__"generic-match.cc", __LINE__946);
947	{
948	return true;
949	}
950	next_after_fail49:;
951	}
952	break;
953	}
954	default:;
955	}
956	return false;
957	}
958
959	bool
960	tree_double_value_p (tree t)
961	{
962	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 962, __FUNCTION__))->typed.type);
963	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 963, __FUNCTION__) )->base.side_effects_flag)) return false;
964	{
965	/* #line 6888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
966	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
967	/* #line 6888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
968	if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 968, __FUNCTION__))->typed. type)), (tcc_type), "generic-match.cc", 968, __FUNCTION__))-> type_common.main_variant) == double_type_nodeglobal_trees[TI_DOUBLE_TYPE]
969	)
970	{
971	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 6887, __FILE__"generic-match.cc", __LINE__971);
972	{
973	return true;
974	}
975	next_after_fail50:;
976	}
977	}
978	return false;
979	}
980
981	bool
982	tree_float_value_p (tree t)
983	{
984	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 984, __FUNCTION__))->typed.type);
985	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 985, __FUNCTION__) )->base.side_effects_flag)) return false;
986	{
987	/* #line 6909 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
988	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
989	/* #line 6909 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
990	if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 990, __FUNCTION__))->typed. type)), (tcc_type), "generic-match.cc", 990, __FUNCTION__))-> type_common.main_variant) == float_type_nodeglobal_trees[TI_FLOAT_TYPE]
991	)
992	{
993	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 6908, __FILE__"generic-match.cc", __LINE__993);
994	{
995	return true;
996	}
997	next_after_fail51:;
998	}
999	}
1000	return false;
1001	}
1002
1003	bool
1004	tree_vec_same_elem_p (tree t)
1005	{
1006	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 1006, __FUNCTION__))->typed.type);
1007	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 1007, __FUNCTION__ ))->base.side_effects_flag)) return false;
1008	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1009	{
1010	case VEC_DUPLICATE_EXPR:
1011	{
1012	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 1012, __FUNCTION__)))));
1013	{
1014	/* #line 8274 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1015	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
1016	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8274, __FILE__"generic-match.cc", __LINE__1016);
1017	{
1018	return true;
1019	}
1020	next_after_fail52:;
1021	}
1022	break;
1023	}
1024	case CONSTRUCTOR:
1025	{
1026	{
1027	/* #line 8278 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1028	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
1029	/* #line 8278 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1030	if (TREE_CODE (captures[0])((enum tree_code) (captures[0])->base.code) == SSA_NAME
1031	&& uniform_vector_p (gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])(tree_check ((captures[0]), "generic-match.cc", 1031, __FUNCTION__ , (SSA_NAME)))->ssa_name.def_stmt))
1032	)
1033	{
1034	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8277, __FILE__"generic-match.cc", __LINE__1034);
1035	{
1036	return true;
1037	}
1038	next_after_fail53:;
1039	}
1040	}
1041	break;
1042	}
1043	default:;
1044	}
1045	{
1046	/* #line 8283 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1047	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
1048	/* #line 8283 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1049	if (uniform_vector_p (captures[0])
1050	)
1051	{
1052	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8282, __FILE__"generic-match.cc", __LINE__1052);
1053	{
1054	return true;
1055	}
1056	next_after_fail54:;
1057	}
1058	}
1059	return false;
1060	}
1061
1062	bool
1063	tree_ctz_table_index (tree t, tree *res_ops)
1064	{
1065	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 1065, __FUNCTION__))->typed.type);
1066	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 1066, __FUNCTION__ ))->base.side_effects_flag)) return false;
1067	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1068	{
1069	case RSHIFT_EXPR:
1070	{
1071	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 1071, __FUNCTION__)))));
1072	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 1072, __FUNCTION__)))));
1073	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1074	{
1075	case MULT_EXPR:
1076	{
1077	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1077, __FUNCTION__)))));
1078	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 1078, __FUNCTION__)))));
1079	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1080	{
1081	case BIT_AND_EXPR:
1082	{
1083	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 1083, __FUNCTION__)))));
1084	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 1084, __FUNCTION__)))));
1085	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1086	{
1087	case NEGATE_EXPR:
1088	{
1089	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1089, __FUNCTION__)))));
1090	if ((_q31 == _q40 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "generic-match.cc", 1090, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q31, _q40, 0) && types_match (_q31, _q40)))
1091	{
1092	switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1093	{
1094	case INTEGER_CST:
1095	{
1096	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1097	{
1098	case INTEGER_CST:
1099	{
1100	{
1101	/* #line 8353 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1102	tree captures[3] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q40, _q21, _p1 };
1103	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8353, __FILE__"generic-match.cc", __LINE__1103);
1104	{
1105	res_ops[0] = captures[0];
1106	res_ops[1] = captures[1];
1107	res_ops[2] = captures[2];
1108	return true;
1109	}
1110	next_after_fail55:;
1111	}
1112	break;
1113	}
1114	default:;
1115	}
1116	break;
1117	}
1118	default:;
1119	}
1120	}
1121	break;
1122	}
1123	default:;
1124	}
1125	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
1126	{
1127	case NEGATE_EXPR:
1128	{
1129	tree _q50 = TREE_OPERAND (_q31, 0)(((const_cast<tree> (tree_operand_check ((_q31), (0), "generic-match.cc", 1129, __FUNCTION__)))));
1130	if ((_q50 == _q30 && ! TREE_SIDE_EFFECTS (_q50)((non_type_check ((_q50), "generic-match.cc", 1130, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q50, _q30, 0) && types_match (_q50, _q30)))
1131	{
1132	switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1133	{
1134	case INTEGER_CST:
1135	{
1136	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1137	{
1138	case INTEGER_CST:
1139	{
1140	{
1141	/* #line 8353 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1142	tree captures[3] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q21, _p1 };
1143	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8353, __FILE__"generic-match.cc", __LINE__1143);
1144	{
1145	res_ops[0] = captures[0];
1146	res_ops[1] = captures[1];
1147	res_ops[2] = captures[2];
1148	return true;
1149	}
1150	next_after_fail56:;
1151	}
1152	break;
1153	}
1154	default:;
1155	}
1156	break;
1157	}
1158	default:;
1159	}
1160	}
1161	break;
1162	}
1163	default:;
1164	}
1165	break;
1166	}
1167	default:;
1168	}
1169	break;
1170	}
1171	default:;
1172	}
1173	break;
1174	}
1175	default:;
1176	}
1177	return false;
1178	}
1179
1180	bool
1181	tree_cond_expr_convert_p (tree t, tree *res_ops)
1182	{
1183	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 1183, __FUNCTION__))->typed.type);
1184	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 1184, __FUNCTION__ ))->base.side_effects_flag)) return false;
1185	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1186	{
1187	case COND_EXPR:
1188	{
1189	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 1189, __FUNCTION__)))));
1190	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 1190, __FUNCTION__)))));
1191	tree _p2 = TREE_OPERAND (t, 2)(((const_cast<tree> (tree_operand_check ((t), (2), "generic-match.cc" , 1191, __FUNCTION__)))));
1192	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1193	{
1194	case LT_EXPR:
1195	{
1196	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1196, __FUNCTION__)))));
1197	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 1197, __FUNCTION__)))));
1198	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1199	{
1200	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1201	{
1202	tree _q50 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 1202, __FUNCTION__)))));
1203	switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1204	{
1205	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1206	{
1207	tree _q70 = TREE_OPERAND (_p2, 0)(((const_cast<tree> (tree_operand_check ((_p2), (0), "generic-match.cc" , 1207, __FUNCTION__)))));
1208	{
1209	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1210	tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1211	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1212	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
1213	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1213, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 1213, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 1213, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1214	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1214, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 1214, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 1214, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1215	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1215, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 1215, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 1215, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1216	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1216 , __FUNCTION__))->type_common.precision) != TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1216, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1216, __FUNCTION__)) ->type_common.precision)
1217	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1217, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1217, __FUNCTION__)) ->type_common.precision)
1218	== TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1218, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1218, __FUNCTION__)) ->type_common.precision)
1219	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1219, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1219, __FUNCTION__)) ->type_common.precision)
1220	== TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1220, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1220, __FUNCTION__)) ->type_common.precision)
1221	&& (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1221, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1221, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1221 , __FUNCTION__))->type_common.precision)
1222	\|\| (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1222, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1222, __FUNCTION__)) ->base.u.bits.unsigned_flag)
1223	== TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1223, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1223, __FUNCTION__)) ->base.u.bits.unsigned_flag)))
1224	&& single_use (captures[5])
1225	&& single_use (captures[6])
1226	)
1227	{
1228	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1228);
1229	{
1230	res_ops[0] = captures[0];
1231	res_ops[1] = captures[1];
1232	res_ops[2] = captures[2];
1233	res_ops[3] = captures[3];
1234	return true;
1235	}
1236	next_after_fail57:;
1237	}
1238	}
1239	break;
1240	}
1241	default:;
1242	}
1243	break;
1244	}
1245	default:;
1246	}
1247	break;
1248	}
1249	case LE_EXPR:
1250	{
1251	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1251, __FUNCTION__)))));
1252	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 1252, __FUNCTION__)))));
1253	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1254	{
1255	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1256	{
1257	tree _q50 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 1257, __FUNCTION__)))));
1258	switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1259	{
1260	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1261	{
1262	tree _q70 = TREE_OPERAND (_p2, 0)(((const_cast<tree> (tree_operand_check ((_p2), (0), "generic-match.cc" , 1262, __FUNCTION__)))));
1263	{
1264	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1265	tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1266	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1267	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
1268	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1268, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 1268, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 1268, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1269	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1269, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 1269, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 1269, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1270	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1270, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 1270, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 1270, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1271	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1271 , __FUNCTION__))->type_common.precision) != TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1271, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1271, __FUNCTION__)) ->type_common.precision)
1272	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1272, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1272, __FUNCTION__)) ->type_common.precision)
1273	== TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1273, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1273, __FUNCTION__)) ->type_common.precision)
1274	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1274, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1274, __FUNCTION__)) ->type_common.precision)
1275	== TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1275, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1275, __FUNCTION__)) ->type_common.precision)
1276	&& (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1276, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1276, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1276 , __FUNCTION__))->type_common.precision)
1277	\|\| (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1277, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1277, __FUNCTION__)) ->base.u.bits.unsigned_flag)
1278	== TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1278, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1278, __FUNCTION__)) ->base.u.bits.unsigned_flag)))
1279	&& single_use (captures[5])
1280	&& single_use (captures[6])
1281	)
1282	{
1283	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1283);
1284	{
1285	res_ops[0] = captures[0];
1286	res_ops[1] = captures[1];
1287	res_ops[2] = captures[2];
1288	res_ops[3] = captures[3];
1289	return true;
1290	}
1291	next_after_fail58:;
1292	}
1293	}
1294	break;
1295	}
1296	default:;
1297	}
1298	break;
1299	}
1300	default:;
1301	}
1302	break;
1303	}
1304	case EQ_EXPR:
1305	{
1306	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1306, __FUNCTION__)))));
1307	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 1307, __FUNCTION__)))));
1308	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1309	{
1310	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1311	{
1312	tree _q50 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 1312, __FUNCTION__)))));
1313	switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1314	{
1315	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1316	{
1317	tree _q70 = TREE_OPERAND (_p2, 0)(((const_cast<tree> (tree_operand_check ((_p2), (0), "generic-match.cc" , 1317, __FUNCTION__)))));
1318	{
1319	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1320	tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1321	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1322	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
1323	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1323, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 1323, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 1323, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1324	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1324, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 1324, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 1324, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1325	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1325, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 1325, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 1325, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1326	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1326 , __FUNCTION__))->type_common.precision) != TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1326, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1326, __FUNCTION__)) ->type_common.precision)
1327	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1327, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1327, __FUNCTION__)) ->type_common.precision)
1328	== TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1328, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1328, __FUNCTION__)) ->type_common.precision)
1329	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1329, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1329, __FUNCTION__)) ->type_common.precision)
1330	== TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1330, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1330, __FUNCTION__)) ->type_common.precision)
1331	&& (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1331, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1331, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1331 , __FUNCTION__))->type_common.precision)
1332	\|\| (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1332, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1332, __FUNCTION__)) ->base.u.bits.unsigned_flag)
1333	== TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1333, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1333, __FUNCTION__)) ->base.u.bits.unsigned_flag)))
1334	&& single_use (captures[5])
1335	&& single_use (captures[6])
1336	)
1337	{
1338	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1338);
1339	{
1340	res_ops[0] = captures[0];
1341	res_ops[1] = captures[1];
1342	res_ops[2] = captures[2];
1343	res_ops[3] = captures[3];
1344	return true;
1345	}
1346	next_after_fail59:;
1347	}
1348	}
1349	break;
1350	}
1351	default:;
1352	}
1353	break;
1354	}
1355	default:;
1356	}
1357	break;
1358	}
1359	case NE_EXPR:
1360	{
1361	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1361, __FUNCTION__)))));
1362	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 1362, __FUNCTION__)))));
1363	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1364	{
1365	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1366	{
1367	tree _q50 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 1367, __FUNCTION__)))));
1368	switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1369	{
1370	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1371	{
1372	tree _q70 = TREE_OPERAND (_p2, 0)(((const_cast<tree> (tree_operand_check ((_p2), (0), "generic-match.cc" , 1372, __FUNCTION__)))));
1373	{
1374	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1375	tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1376	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1377	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
1378	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1378, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 1378, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 1378, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1379	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1379, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 1379, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 1379, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1380	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1380, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 1380, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 1380, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1381	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1381 , __FUNCTION__))->type_common.precision) != TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1381, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1381, __FUNCTION__)) ->type_common.precision)
1382	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1382, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1382, __FUNCTION__)) ->type_common.precision)
1383	== TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1383, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1383, __FUNCTION__)) ->type_common.precision)
1384	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1384, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1384, __FUNCTION__)) ->type_common.precision)
1385	== TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1385, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1385, __FUNCTION__)) ->type_common.precision)
1386	&& (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1386, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1386, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1386 , __FUNCTION__))->type_common.precision)
1387	\|\| (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1387, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1387, __FUNCTION__)) ->base.u.bits.unsigned_flag)
1388	== TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1388, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1388, __FUNCTION__)) ->base.u.bits.unsigned_flag)))
1389	&& single_use (captures[5])
1390	&& single_use (captures[6])
1391	)
1392	{
1393	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1393);
1394	{
1395	res_ops[0] = captures[0];
1396	res_ops[1] = captures[1];
1397	res_ops[2] = captures[2];
1398	res_ops[3] = captures[3];
1399	return true;
1400	}
1401	next_after_fail60:;
1402	}
1403	}
1404	break;
1405	}
1406	default:;
1407	}
1408	break;
1409	}
1410	default:;
1411	}
1412	break;
1413	}
1414	case GE_EXPR:
1415	{
1416	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1416, __FUNCTION__)))));
1417	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 1417, __FUNCTION__)))));
1418	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1419	{
1420	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1421	{
1422	tree _q50 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 1422, __FUNCTION__)))));
1423	switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1424	{
1425	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1426	{
1427	tree _q70 = TREE_OPERAND (_p2, 0)(((const_cast<tree> (tree_operand_check ((_p2), (0), "generic-match.cc" , 1427, __FUNCTION__)))));
1428	{
1429	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1430	tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1431	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1432	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
1433	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1433, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 1433, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 1433, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1434	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1434, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 1434, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 1434, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1435	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1435, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 1435, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 1435, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1436	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1436 , __FUNCTION__))->type_common.precision) != TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1436, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1436, __FUNCTION__)) ->type_common.precision)
1437	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1437, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1437, __FUNCTION__)) ->type_common.precision)
1438	== TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1438, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1438, __FUNCTION__)) ->type_common.precision)
1439	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1439, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1439, __FUNCTION__)) ->type_common.precision)
1440	== TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1440, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1440, __FUNCTION__)) ->type_common.precision)
1441	&& (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1441, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1441, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1441 , __FUNCTION__))->type_common.precision)
1442	\|\| (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1442, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1442, __FUNCTION__)) ->base.u.bits.unsigned_flag)
1443	== TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1443, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1443, __FUNCTION__)) ->base.u.bits.unsigned_flag)))
1444	&& single_use (captures[5])
1445	&& single_use (captures[6])
1446	)
1447	{
1448	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1448);
1449	{
1450	res_ops[0] = captures[0];
1451	res_ops[1] = captures[1];
1452	res_ops[2] = captures[2];
1453	res_ops[3] = captures[3];
1454	return true;
1455	}
1456	next_after_fail61:;
1457	}
1458	}
1459	break;
1460	}
1461	default:;
1462	}
1463	break;
1464	}
1465	default:;
1466	}
1467	break;
1468	}
1469	case GT_EXPR:
1470	{
1471	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1471, __FUNCTION__)))));
1472	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 1472, __FUNCTION__)))));
1473	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1474	{
1475	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1476	{
1477	tree _q50 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 1477, __FUNCTION__)))));
1478	switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1479	{
1480	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1481	{
1482	tree _q70 = TREE_OPERAND (_p2, 0)(((const_cast<tree> (tree_operand_check ((_p2), (0), "generic-match.cc" , 1482, __FUNCTION__)))));
1483	{
1484	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1485	tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1486	/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1487	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
1488	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1488, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 1488, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 1488, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1489	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1489, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 1489, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 1489, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1490	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1490, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 1490, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 1490, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
1491	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1491 , __FUNCTION__))->type_common.precision) != TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1491, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1491, __FUNCTION__)) ->type_common.precision)
1492	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1492, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1492, __FUNCTION__)) ->type_common.precision)
1493	== TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1493, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1493, __FUNCTION__)) ->type_common.precision)
1494	&& TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1494, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1494, __FUNCTION__)) ->type_common.precision)
1495	== TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1495, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1495, __FUNCTION__)) ->type_common.precision)
1496	&& (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 1496, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1496, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1496 , __FUNCTION__))->type_common.precision)
1497	\|\| (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 1497, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1497, __FUNCTION__)) ->base.u.bits.unsigned_flag)
1498	== TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 1498, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 1498, __FUNCTION__)) ->base.u.bits.unsigned_flag)))
1499	&& single_use (captures[5])
1500	&& single_use (captures[6])
1501	)
1502	{
1503	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1503);
1504	{
1505	res_ops[0] = captures[0];
1506	res_ops[1] = captures[1];
1507	res_ops[2] = captures[2];
1508	res_ops[3] = captures[3];
1509	return true;
1510	}
1511	next_after_fail62:;
1512	}
1513	}
1514	break;
1515	}
1516	default:;
1517	}
1518	break;
1519	}
1520	default:;
1521	}
1522	break;
1523	}
1524	default:;
1525	}
1526	break;
1527	}
1528	default:;
1529	}
1530	return false;
1531	}
1532
1533	bool
1534	tree_bitwise_induction_p (tree t, tree *res_ops)
1535	{
1536	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc", 1536, __FUNCTION__))->typed.type);
1537	if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 1537, __FUNCTION__ ))->base.side_effects_flag)) return false;
1538	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1539	{
1540	case BIT_AND_EXPR:
1541	{
1542	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 1542, __FUNCTION__)))));
1543	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 1543, __FUNCTION__)))));
1544	{
1545	tree _p0_pops[1];
1546	if (tree_nop_convert (_p0, _p0_pops))
1547	{
1548	tree _q20 = _p0_pops[0];
1549	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1550	{
1551	case BIT_NOT_EXPR:
1552	{
1553	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 1553, __FUNCTION__)))));
1554	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1555	{
1556	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1557	{
1558	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1558, __FUNCTION__)))));
1559	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
1560	{
1561	case LSHIFT_EXPR:
1562	{
1563	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 1563, __FUNCTION__)))));
1564	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 1564, __FUNCTION__)))));
1565	if (integer_onep (_q50))
1566	{
1567	{
1568	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1569	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q51, _p1, _q50 };
1570	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1570);
1571	{
1572	res_ops[0] = captures[0];
1573	res_ops[1] = captures[1];
1574	res_ops[2] = captures[2];
1575	return true;
1576	}
1577	next_after_fail63:;
1578	}
1579	}
1580	break;
1581	}
1582	default:;
1583	}
1584	break;
1585	}
1586	case LSHIFT_EXPR:
1587	{
1588	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1588, __FUNCTION__)))));
1589	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 1589, __FUNCTION__)))));
1590	if (integer_onep (_q40))
1591	{
1592	{
1593	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1594	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
1595	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1595);
1596	{
1597	res_ops[0] = captures[0];
1598	res_ops[1] = captures[1];
1599	res_ops[2] = captures[2];
1600	return true;
1601	}
1602	next_after_fail64:;
1603	}
1604	}
1605	break;
1606	}
1607	default:;
1608	}
1609	break;
1610	}
1611	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1612	{
1613	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 1613, __FUNCTION__)))));
1614	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1615	{
1616	case LSHIFT_EXPR:
1617	{
1618	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1618, __FUNCTION__)))));
1619	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 1619, __FUNCTION__)))));
1620	if (integer_onep (_q40))
1621	{
1622	{
1623	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1624	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
1625	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1625);
1626	{
1627	res_ops[0] = captures[0];
1628	res_ops[1] = captures[1];
1629	res_ops[2] = captures[2];
1630	return true;
1631	}
1632	next_after_fail65:;
1633	}
1634	}
1635	break;
1636	}
1637	default:;
1638	}
1639	break;
1640	}
1641	case LSHIFT_EXPR:
1642	{
1643	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 1643, __FUNCTION__)))));
1644	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 1644, __FUNCTION__)))));
1645	if (integer_onep (_q30))
1646	{
1647	{
1648	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1649	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q31, _p1, _q30 };
1650	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1650);
1651	{
1652	res_ops[0] = captures[0];
1653	res_ops[1] = captures[1];
1654	res_ops[2] = captures[2];
1655	return true;
1656	}
1657	next_after_fail66:;
1658	}
1659	}
1660	break;
1661	}
1662	default:;
1663	}
1664	}
1665	}
1666	{
1667	tree _p1_pops[1];
1668	if (tree_nop_convert (_p1, _p1_pops))
1669	{
1670	tree _q30 = _p1_pops[0];
1671	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1672	{
1673	case BIT_NOT_EXPR:
1674	{
1675	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1675, __FUNCTION__)))));
1676	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
1677	{
1678	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1679	{
1680	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 1680, __FUNCTION__)))));
1681	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
1682	{
1683	case LSHIFT_EXPR:
1684	{
1685	tree _q60 = TREE_OPERAND (_q50, 0)(((const_cast<tree> (tree_operand_check ((_q50), (0), "generic-match.cc", 1685, __FUNCTION__)))));
1686	tree _q61 = TREE_OPERAND (_q50, 1)(((const_cast<tree> (tree_operand_check ((_q50), (1), "generic-match.cc", 1686, __FUNCTION__)))));
1687	if (integer_onep (_q60))
1688	{
1689	{
1690	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1691	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q61, _p0, _q60 };
1692	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1692);
1693	{
1694	res_ops[0] = captures[0];
1695	res_ops[1] = captures[1];
1696	res_ops[2] = captures[2];
1697	return true;
1698	}
1699	next_after_fail67:;
1700	}
1701	}
1702	break;
1703	}
1704	default:;
1705	}
1706	break;
1707	}
1708	case LSHIFT_EXPR:
1709	{
1710	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 1710, __FUNCTION__)))));
1711	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 1711, __FUNCTION__)))));
1712	if (integer_onep (_q50))
1713	{
1714	{
1715	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1716	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
1717	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1717);
1718	{
1719	res_ops[0] = captures[0];
1720	res_ops[1] = captures[1];
1721	res_ops[2] = captures[2];
1722	return true;
1723	}
1724	next_after_fail68:;
1725	}
1726	}
1727	break;
1728	}
1729	default:;
1730	}
1731	break;
1732	}
1733	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1734	{
1735	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1735, __FUNCTION__)))));
1736	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
1737	{
1738	case LSHIFT_EXPR:
1739	{
1740	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 1740, __FUNCTION__)))));
1741	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 1741, __FUNCTION__)))));
1742	if (integer_onep (_q50))
1743	{
1744	{
1745	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1746	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
1747	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1747);
1748	{
1749	res_ops[0] = captures[0];
1750	res_ops[1] = captures[1];
1751	res_ops[2] = captures[2];
1752	return true;
1753	}
1754	next_after_fail69:;
1755	}
1756	}
1757	break;
1758	}
1759	default:;
1760	}
1761	break;
1762	}
1763	case LSHIFT_EXPR:
1764	{
1765	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1765, __FUNCTION__)))));
1766	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 1766, __FUNCTION__)))));
1767	if (integer_onep (_q40))
1768	{
1769	{
1770	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1771	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q41, _p0, _q40 };
1772	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1772);
1773	{
1774	res_ops[0] = captures[0];
1775	res_ops[1] = captures[1];
1776	res_ops[2] = captures[2];
1777	return true;
1778	}
1779	next_after_fail70:;
1780	}
1781	}
1782	break;
1783	}
1784	default:;
1785	}
1786	}
1787	}
1788	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1789	{
1790	case BIT_NOT_EXPR:
1791	{
1792	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1792, __FUNCTION__)))));
1793	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1794	{
1795	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1796	{
1797	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 1797, __FUNCTION__)))));
1798	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1799	{
1800	case LSHIFT_EXPR:
1801	{
1802	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1802, __FUNCTION__)))));
1803	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 1803, __FUNCTION__)))));
1804	if (integer_onep (_q40))
1805	{
1806	{
1807	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1808	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q41, _p1, _q40 };
1809	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1809);
1810	{
1811	res_ops[0] = captures[0];
1812	res_ops[1] = captures[1];
1813	res_ops[2] = captures[2];
1814	return true;
1815	}
1816	next_after_fail71:;
1817	}
1818	}
1819	break;
1820	}
1821	default:;
1822	}
1823	break;
1824	}
1825	case LSHIFT_EXPR:
1826	{
1827	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 1827, __FUNCTION__)))));
1828	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 1828, __FUNCTION__)))));
1829	if (integer_onep (_q30))
1830	{
1831	{
1832	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1833	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
1834	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1834);
1835	{
1836	res_ops[0] = captures[0];
1837	res_ops[1] = captures[1];
1838	res_ops[2] = captures[2];
1839	return true;
1840	}
1841	next_after_fail72:;
1842	}
1843	}
1844	break;
1845	}
1846	default:;
1847	}
1848	break;
1849	}
1850	default:;
1851	}
1852	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1853	{
1854	case BIT_NOT_EXPR:
1855	{
1856	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 1856, __FUNCTION__)))));
1857	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1858	{
1859	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1860	{
1861	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1861, __FUNCTION__)))));
1862	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
1863	{
1864	case LSHIFT_EXPR:
1865	{
1866	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 1866, __FUNCTION__)))));
1867	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 1867, __FUNCTION__)))));
1868	if (integer_onep (_q50))
1869	{
1870	{
1871	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1872	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q51, _p0, _q50 };
1873	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1873);
1874	{
1875	res_ops[0] = captures[0];
1876	res_ops[1] = captures[1];
1877	res_ops[2] = captures[2];
1878	return true;
1879	}
1880	next_after_fail73:;
1881	}
1882	}
1883	break;
1884	}
1885	default:;
1886	}
1887	break;
1888	}
1889	case LSHIFT_EXPR:
1890	{
1891	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1891, __FUNCTION__)))));
1892	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 1892, __FUNCTION__)))));
1893	if (integer_onep (_q40))
1894	{
1895	{
1896	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1897	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
1898	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1898);
1899	{
1900	res_ops[0] = captures[0];
1901	res_ops[1] = captures[1];
1902	res_ops[2] = captures[2];
1903	return true;
1904	}
1905	next_after_fail74:;
1906	}
1907	}
1908	break;
1909	}
1910	default:;
1911	}
1912	break;
1913	}
1914	default:;
1915	}
1916	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1917	{
1918	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1919	{
1920	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1920, __FUNCTION__)))));
1921	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1922	{
1923	case LSHIFT_EXPR:
1924	{
1925	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 1925, __FUNCTION__)))));
1926	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 1926, __FUNCTION__)))));
1927	if (integer_onep (_q30))
1928	{
1929	{
1930	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1931	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
1932	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1932);
1933	{
1934	res_ops[0] = captures[0];
1935	res_ops[1] = captures[1];
1936	res_ops[2] = captures[2];
1937	return true;
1938	}
1939	next_after_fail75:;
1940	}
1941	}
1942	break;
1943	}
1944	default:;
1945	}
1946	break;
1947	}
1948	default:;
1949	}
1950	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1951	{
1952	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1953	{
1954	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 1954, __FUNCTION__)))));
1955	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1956	{
1957	case LSHIFT_EXPR:
1958	{
1959	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 1959, __FUNCTION__)))));
1960	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 1960, __FUNCTION__)))));
1961	if (integer_onep (_q40))
1962	{
1963	{
1964	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1965	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
1966	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1966);
1967	{
1968	res_ops[0] = captures[0];
1969	res_ops[1] = captures[1];
1970	res_ops[2] = captures[2];
1971	return true;
1972	}
1973	next_after_fail76:;
1974	}
1975	}
1976	break;
1977	}
1978	default:;
1979	}
1980	break;
1981	}
1982	default:;
1983	}
1984	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1985	{
1986	case LSHIFT_EXPR:
1987	{
1988	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 1988, __FUNCTION__)))));
1989	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 1989, __FUNCTION__)))));
1990	if (integer_onep (_q20))
1991	{
1992	{
1993	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1994	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q21, _p1, _q20 };
1995	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1995);
1996	{
1997	res_ops[0] = captures[0];
1998	res_ops[1] = captures[1];
1999	res_ops[2] = captures[2];
2000	return true;
2001	}
2002	next_after_fail77:;
2003	}
2004	}
2005	break;
2006	}
2007	default:;
2008	}
2009	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2010	{
2011	case LSHIFT_EXPR:
2012	{
2013	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 2013, __FUNCTION__)))));
2014	tree _q31 = TREE_OPERAND (_p1, 1)(((const_cast<tree> (tree_operand_check ((_p1), (1), "generic-match.cc" , 2014, __FUNCTION__)))));
2015	if (integer_onep (_q30))
2016	{
2017	{
2018	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2019	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q31, _p0, _q30 };
2020	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2020);
2021	{
2022	res_ops[0] = captures[0];
2023	res_ops[1] = captures[1];
2024	res_ops[2] = captures[2];
2025	return true;
2026	}
2027	next_after_fail78:;
2028	}
2029	}
2030	break;
2031	}
2032	default:;
2033	}
2034	break;
2035	}
2036	case BIT_IOR_EXPR:
2037	{
2038	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 2038, __FUNCTION__)))));
2039	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 2039, __FUNCTION__)))));
2040	{
2041	tree _p0_pops[1];
2042	if (tree_nop_convert (_p0, _p0_pops))
2043	{
2044	tree _q20 = _p0_pops[0];
2045	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2046	{
2047	case BIT_NOT_EXPR:
2048	{
2049	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2049, __FUNCTION__)))));
2050	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2051	{
2052	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2053	{
2054	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2054, __FUNCTION__)))));
2055	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2056	{
2057	case LSHIFT_EXPR:
2058	{
2059	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2059, __FUNCTION__)))));
2060	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 2060, __FUNCTION__)))));
2061	if (integer_onep (_q50))
2062	{
2063	{
2064	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2065	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q51, _p1, _q50 };
2066	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2066);
2067	{
2068	res_ops[0] = captures[0];
2069	res_ops[1] = captures[1];
2070	res_ops[2] = captures[2];
2071	return true;
2072	}
2073	next_after_fail79:;
2074	}
2075	}
2076	break;
2077	}
2078	default:;
2079	}
2080	break;
2081	}
2082	case LSHIFT_EXPR:
2083	{
2084	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2084, __FUNCTION__)))));
2085	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2085, __FUNCTION__)))));
2086	if (integer_onep (_q40))
2087	{
2088	{
2089	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2090	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
2091	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2091);
2092	{
2093	res_ops[0] = captures[0];
2094	res_ops[1] = captures[1];
2095	res_ops[2] = captures[2];
2096	return true;
2097	}
2098	next_after_fail80:;
2099	}
2100	}
2101	break;
2102	}
2103	default:;
2104	}
2105	break;
2106	}
2107	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2108	{
2109	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2109, __FUNCTION__)))));
2110	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2111	{
2112	case LSHIFT_EXPR:
2113	{
2114	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2114, __FUNCTION__)))));
2115	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2115, __FUNCTION__)))));
2116	if (integer_onep (_q40))
2117	{
2118	{
2119	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2120	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
2121	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2121);
2122	{
2123	res_ops[0] = captures[0];
2124	res_ops[1] = captures[1];
2125	res_ops[2] = captures[2];
2126	return true;
2127	}
2128	next_after_fail81:;
2129	}
2130	}
2131	break;
2132	}
2133	default:;
2134	}
2135	break;
2136	}
2137	case LSHIFT_EXPR:
2138	{
2139	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2139, __FUNCTION__)))));
2140	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 2140, __FUNCTION__)))));
2141	if (integer_onep (_q30))
2142	{
2143	{
2144	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2145	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q31, _p1, _q30 };
2146	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2146);
2147	{
2148	res_ops[0] = captures[0];
2149	res_ops[1] = captures[1];
2150	res_ops[2] = captures[2];
2151	return true;
2152	}
2153	next_after_fail82:;
2154	}
2155	}
2156	break;
2157	}
2158	default:;
2159	}
2160	}
2161	}
2162	{
2163	tree _p1_pops[1];
2164	if (tree_nop_convert (_p1, _p1_pops))
2165	{
2166	tree _q30 = _p1_pops[0];
2167	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2168	{
2169	case BIT_NOT_EXPR:
2170	{
2171	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2171, __FUNCTION__)))));
2172	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2173	{
2174	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2175	{
2176	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2176, __FUNCTION__)))));
2177	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
2178	{
2179	case LSHIFT_EXPR:
2180	{
2181	tree _q60 = TREE_OPERAND (_q50, 0)(((const_cast<tree> (tree_operand_check ((_q50), (0), "generic-match.cc", 2181, __FUNCTION__)))));
2182	tree _q61 = TREE_OPERAND (_q50, 1)(((const_cast<tree> (tree_operand_check ((_q50), (1), "generic-match.cc", 2182, __FUNCTION__)))));
2183	if (integer_onep (_q60))
2184	{
2185	{
2186	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2187	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q61, _p0, _q60 };
2188	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2188);
2189	{
2190	res_ops[0] = captures[0];
2191	res_ops[1] = captures[1];
2192	res_ops[2] = captures[2];
2193	return true;
2194	}
2195	next_after_fail83:;
2196	}
2197	}
2198	break;
2199	}
2200	default:;
2201	}
2202	break;
2203	}
2204	case LSHIFT_EXPR:
2205	{
2206	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2206, __FUNCTION__)))));
2207	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 2207, __FUNCTION__)))));
2208	if (integer_onep (_q50))
2209	{
2210	{
2211	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2212	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
2213	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2213);
2214	{
2215	res_ops[0] = captures[0];
2216	res_ops[1] = captures[1];
2217	res_ops[2] = captures[2];
2218	return true;
2219	}
2220	next_after_fail84:;
2221	}
2222	}
2223	break;
2224	}
2225	default:;
2226	}
2227	break;
2228	}
2229	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2230	{
2231	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2231, __FUNCTION__)))));
2232	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2233	{
2234	case LSHIFT_EXPR:
2235	{
2236	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2236, __FUNCTION__)))));
2237	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 2237, __FUNCTION__)))));
2238	if (integer_onep (_q50))
2239	{
2240	{
2241	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2242	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
2243	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2243);
2244	{
2245	res_ops[0] = captures[0];
2246	res_ops[1] = captures[1];
2247	res_ops[2] = captures[2];
2248	return true;
2249	}
2250	next_after_fail85:;
2251	}
2252	}
2253	break;
2254	}
2255	default:;
2256	}
2257	break;
2258	}
2259	case LSHIFT_EXPR:
2260	{
2261	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2261, __FUNCTION__)))));
2262	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2262, __FUNCTION__)))));
2263	if (integer_onep (_q40))
2264	{
2265	{
2266	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2267	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q41, _p0, _q40 };
2268	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2268);
2269	{
2270	res_ops[0] = captures[0];
2271	res_ops[1] = captures[1];
2272	res_ops[2] = captures[2];
2273	return true;
2274	}
2275	next_after_fail86:;
2276	}
2277	}
2278	break;
2279	}
2280	default:;
2281	}
2282	}
2283	}
2284	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2285	{
2286	case BIT_NOT_EXPR:
2287	{
2288	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 2288, __FUNCTION__)))));
2289	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2290	{
2291	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2292	{
2293	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2293, __FUNCTION__)))));
2294	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2295	{
2296	case LSHIFT_EXPR:
2297	{
2298	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2298, __FUNCTION__)))));
2299	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2299, __FUNCTION__)))));
2300	if (integer_onep (_q40))
2301	{
2302	{
2303	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2304	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q41, _p1, _q40 };
2305	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2305);
2306	{
2307	res_ops[0] = captures[0];
2308	res_ops[1] = captures[1];
2309	res_ops[2] = captures[2];
2310	return true;
2311	}
2312	next_after_fail87:;
2313	}
2314	}
2315	break;
2316	}
2317	default:;
2318	}
2319	break;
2320	}
2321	case LSHIFT_EXPR:
2322	{
2323	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2323, __FUNCTION__)))));
2324	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 2324, __FUNCTION__)))));
2325	if (integer_onep (_q30))
2326	{
2327	{
2328	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2329	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
2330	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2330);
2331	{
2332	res_ops[0] = captures[0];
2333	res_ops[1] = captures[1];
2334	res_ops[2] = captures[2];
2335	return true;
2336	}
2337	next_after_fail88:;
2338	}
2339	}
2340	break;
2341	}
2342	default:;
2343	}
2344	break;
2345	}
2346	default:;
2347	}
2348	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2349	{
2350	case BIT_NOT_EXPR:
2351	{
2352	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 2352, __FUNCTION__)))));
2353	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2354	{
2355	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2356	{
2357	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2357, __FUNCTION__)))));
2358	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2359	{
2360	case LSHIFT_EXPR:
2361	{
2362	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2362, __FUNCTION__)))));
2363	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 2363, __FUNCTION__)))));
2364	if (integer_onep (_q50))
2365	{
2366	{
2367	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2368	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q51, _p0, _q50 };
2369	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2369);
2370	{
2371	res_ops[0] = captures[0];
2372	res_ops[1] = captures[1];
2373	res_ops[2] = captures[2];
2374	return true;
2375	}
2376	next_after_fail89:;
2377	}
2378	}
2379	break;
2380	}
2381	default:;
2382	}
2383	break;
2384	}
2385	case LSHIFT_EXPR:
2386	{
2387	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2387, __FUNCTION__)))));
2388	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2388, __FUNCTION__)))));
2389	if (integer_onep (_q40))
2390	{
2391	{
2392	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2393	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
2394	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2394);
2395	{
2396	res_ops[0] = captures[0];
2397	res_ops[1] = captures[1];
2398	res_ops[2] = captures[2];
2399	return true;
2400	}
2401	next_after_fail90:;
2402	}
2403	}
2404	break;
2405	}
2406	default:;
2407	}
2408	break;
2409	}
2410	default:;
2411	}
2412	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2413	{
2414	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2415	{
2416	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 2416, __FUNCTION__)))));
2417	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2418	{
2419	case LSHIFT_EXPR:
2420	{
2421	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2421, __FUNCTION__)))));
2422	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 2422, __FUNCTION__)))));
2423	if (integer_onep (_q30))
2424	{
2425	{
2426	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2427	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
2428	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2428);
2429	{
2430	res_ops[0] = captures[0];
2431	res_ops[1] = captures[1];
2432	res_ops[2] = captures[2];
2433	return true;
2434	}
2435	next_after_fail91:;
2436	}
2437	}
2438	break;
2439	}
2440	default:;
2441	}
2442	break;
2443	}
2444	default:;
2445	}
2446	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2447	{
2448	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2449	{
2450	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 2450, __FUNCTION__)))));
2451	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2452	{
2453	case LSHIFT_EXPR:
2454	{
2455	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2455, __FUNCTION__)))));
2456	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2456, __FUNCTION__)))));
2457	if (integer_onep (_q40))
2458	{
2459	{
2460	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2461	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
2462	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2462);
2463	{
2464	res_ops[0] = captures[0];
2465	res_ops[1] = captures[1];
2466	res_ops[2] = captures[2];
2467	return true;
2468	}
2469	next_after_fail92:;
2470	}
2471	}
2472	break;
2473	}
2474	default:;
2475	}
2476	break;
2477	}
2478	default:;
2479	}
2480	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2481	{
2482	case LSHIFT_EXPR:
2483	{
2484	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 2484, __FUNCTION__)))));
2485	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 2485, __FUNCTION__)))));
2486	if (integer_onep (_q20))
2487	{
2488	{
2489	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2490	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q21, _p1, _q20 };
2491	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2491);
2492	{
2493	res_ops[0] = captures[0];
2494	res_ops[1] = captures[1];
2495	res_ops[2] = captures[2];
2496	return true;
2497	}
2498	next_after_fail93:;
2499	}
2500	}
2501	break;
2502	}
2503	default:;
2504	}
2505	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2506	{
2507	case LSHIFT_EXPR:
2508	{
2509	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 2509, __FUNCTION__)))));
2510	tree _q31 = TREE_OPERAND (_p1, 1)(((const_cast<tree> (tree_operand_check ((_p1), (1), "generic-match.cc" , 2510, __FUNCTION__)))));
2511	if (integer_onep (_q30))
2512	{
2513	{
2514	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2515	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q31, _p0, _q30 };
2516	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2516);
2517	{
2518	res_ops[0] = captures[0];
2519	res_ops[1] = captures[1];
2520	res_ops[2] = captures[2];
2521	return true;
2522	}
2523	next_after_fail94:;
2524	}
2525	}
2526	break;
2527	}
2528	default:;
2529	}
2530	break;
2531	}
2532	case BIT_XOR_EXPR:
2533	{
2534	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 2534, __FUNCTION__)))));
2535	tree _p1 = TREE_OPERAND (t, 1)(((const_cast<tree> (tree_operand_check ((t), (1), "generic-match.cc" , 2535, __FUNCTION__)))));
2536	{
2537	tree _p0_pops[1];
2538	if (tree_nop_convert (_p0, _p0_pops))
2539	{
2540	tree _q20 = _p0_pops[0];
2541	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2542	{
2543	case BIT_NOT_EXPR:
2544	{
2545	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2545, __FUNCTION__)))));
2546	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2547	{
2548	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2549	{
2550	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2550, __FUNCTION__)))));
2551	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2552	{
2553	case LSHIFT_EXPR:
2554	{
2555	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2555, __FUNCTION__)))));
2556	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 2556, __FUNCTION__)))));
2557	if (integer_onep (_q50))
2558	{
2559	{
2560	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2561	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q51, _p1, _q50 };
2562	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2562);
2563	{
2564	res_ops[0] = captures[0];
2565	res_ops[1] = captures[1];
2566	res_ops[2] = captures[2];
2567	return true;
2568	}
2569	next_after_fail95:;
2570	}
2571	}
2572	break;
2573	}
2574	default:;
2575	}
2576	break;
2577	}
2578	case LSHIFT_EXPR:
2579	{
2580	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2580, __FUNCTION__)))));
2581	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2581, __FUNCTION__)))));
2582	if (integer_onep (_q40))
2583	{
2584	{
2585	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2586	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
2587	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2587);
2588	{
2589	res_ops[0] = captures[0];
2590	res_ops[1] = captures[1];
2591	res_ops[2] = captures[2];
2592	return true;
2593	}
2594	next_after_fail96:;
2595	}
2596	}
2597	break;
2598	}
2599	default:;
2600	}
2601	break;
2602	}
2603	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2604	{
2605	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2605, __FUNCTION__)))));
2606	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2607	{
2608	case LSHIFT_EXPR:
2609	{
2610	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2610, __FUNCTION__)))));
2611	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2611, __FUNCTION__)))));
2612	if (integer_onep (_q40))
2613	{
2614	{
2615	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2616	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
2617	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2617);
2618	{
2619	res_ops[0] = captures[0];
2620	res_ops[1] = captures[1];
2621	res_ops[2] = captures[2];
2622	return true;
2623	}
2624	next_after_fail97:;
2625	}
2626	}
2627	break;
2628	}
2629	default:;
2630	}
2631	break;
2632	}
2633	case LSHIFT_EXPR:
2634	{
2635	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2635, __FUNCTION__)))));
2636	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 2636, __FUNCTION__)))));
2637	if (integer_onep (_q30))
2638	{
2639	{
2640	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2641	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q31, _p1, _q30 };
2642	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2642);
2643	{
2644	res_ops[0] = captures[0];
2645	res_ops[1] = captures[1];
2646	res_ops[2] = captures[2];
2647	return true;
2648	}
2649	next_after_fail98:;
2650	}
2651	}
2652	break;
2653	}
2654	default:;
2655	}
2656	}
2657	}
2658	{
2659	tree _p1_pops[1];
2660	if (tree_nop_convert (_p1, _p1_pops))
2661	{
2662	tree _q30 = _p1_pops[0];
2663	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2664	{
2665	case BIT_NOT_EXPR:
2666	{
2667	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2667, __FUNCTION__)))));
2668	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2669	{
2670	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2671	{
2672	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2672, __FUNCTION__)))));
2673	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
2674	{
2675	case LSHIFT_EXPR:
2676	{
2677	tree _q60 = TREE_OPERAND (_q50, 0)(((const_cast<tree> (tree_operand_check ((_q50), (0), "generic-match.cc", 2677, __FUNCTION__)))));
2678	tree _q61 = TREE_OPERAND (_q50, 1)(((const_cast<tree> (tree_operand_check ((_q50), (1), "generic-match.cc", 2678, __FUNCTION__)))));
2679	if (integer_onep (_q60))
2680	{
2681	{
2682	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2683	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q61, _p0, _q60 };
2684	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2684);
2685	{
2686	res_ops[0] = captures[0];
2687	res_ops[1] = captures[1];
2688	res_ops[2] = captures[2];
2689	return true;
2690	}
2691	next_after_fail99:;
2692	}
2693	}
2694	break;
2695	}
2696	default:;
2697	}
2698	break;
2699	}
2700	case LSHIFT_EXPR:
2701	{
2702	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2702, __FUNCTION__)))));
2703	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 2703, __FUNCTION__)))));
2704	if (integer_onep (_q50))
2705	{
2706	{
2707	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2708	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
2709	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2709);
2710	{
2711	res_ops[0] = captures[0];
2712	res_ops[1] = captures[1];
2713	res_ops[2] = captures[2];
2714	return true;
2715	}
2716	next_after_fail100:;
2717	}
2718	}
2719	break;
2720	}
2721	default:;
2722	}
2723	break;
2724	}
2725	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2726	{
2727	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2727, __FUNCTION__)))));
2728	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2729	{
2730	case LSHIFT_EXPR:
2731	{
2732	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2732, __FUNCTION__)))));
2733	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 2733, __FUNCTION__)))));
2734	if (integer_onep (_q50))
2735	{
2736	{
2737	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2738	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
2739	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2739);
2740	{
2741	res_ops[0] = captures[0];
2742	res_ops[1] = captures[1];
2743	res_ops[2] = captures[2];
2744	return true;
2745	}
2746	next_after_fail101:;
2747	}
2748	}
2749	break;
2750	}
2751	default:;
2752	}
2753	break;
2754	}
2755	case LSHIFT_EXPR:
2756	{
2757	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2757, __FUNCTION__)))));
2758	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2758, __FUNCTION__)))));
2759	if (integer_onep (_q40))
2760	{
2761	{
2762	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2763	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q41, _p0, _q40 };
2764	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2764);
2765	{
2766	res_ops[0] = captures[0];
2767	res_ops[1] = captures[1];
2768	res_ops[2] = captures[2];
2769	return true;
2770	}
2771	next_after_fail102:;
2772	}
2773	}
2774	break;
2775	}
2776	default:;
2777	}
2778	}
2779	}
2780	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2781	{
2782	case BIT_NOT_EXPR:
2783	{
2784	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 2784, __FUNCTION__)))));
2785	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2786	{
2787	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2788	{
2789	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2789, __FUNCTION__)))));
2790	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2791	{
2792	case LSHIFT_EXPR:
2793	{
2794	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2794, __FUNCTION__)))));
2795	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2795, __FUNCTION__)))));
2796	if (integer_onep (_q40))
2797	{
2798	{
2799	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2800	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q41, _p1, _q40 };
2801	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2801);
2802	{
2803	res_ops[0] = captures[0];
2804	res_ops[1] = captures[1];
2805	res_ops[2] = captures[2];
2806	return true;
2807	}
2808	next_after_fail103:;
2809	}
2810	}
2811	break;
2812	}
2813	default:;
2814	}
2815	break;
2816	}
2817	case LSHIFT_EXPR:
2818	{
2819	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2819, __FUNCTION__)))));
2820	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 2820, __FUNCTION__)))));
2821	if (integer_onep (_q30))
2822	{
2823	{
2824	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2825	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
2826	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2826);
2827	{
2828	res_ops[0] = captures[0];
2829	res_ops[1] = captures[1];
2830	res_ops[2] = captures[2];
2831	return true;
2832	}
2833	next_after_fail104:;
2834	}
2835	}
2836	break;
2837	}
2838	default:;
2839	}
2840	break;
2841	}
2842	default:;
2843	}
2844	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2845	{
2846	case BIT_NOT_EXPR:
2847	{
2848	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 2848, __FUNCTION__)))));
2849	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2850	{
2851	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2852	{
2853	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2853, __FUNCTION__)))));
2854	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2855	{
2856	case LSHIFT_EXPR:
2857	{
2858	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 2858, __FUNCTION__)))));
2859	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 2859, __FUNCTION__)))));
2860	if (integer_onep (_q50))
2861	{
2862	{
2863	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2864	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q51, _p0, _q50 };
2865	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2865);
2866	{
2867	res_ops[0] = captures[0];
2868	res_ops[1] = captures[1];
2869	res_ops[2] = captures[2];
2870	return true;
2871	}
2872	next_after_fail105:;
2873	}
2874	}
2875	break;
2876	}
2877	default:;
2878	}
2879	break;
2880	}
2881	case LSHIFT_EXPR:
2882	{
2883	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2883, __FUNCTION__)))));
2884	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2884, __FUNCTION__)))));
2885	if (integer_onep (_q40))
2886	{
2887	{
2888	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2889	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
2890	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2890);
2891	{
2892	res_ops[0] = captures[0];
2893	res_ops[1] = captures[1];
2894	res_ops[2] = captures[2];
2895	return true;
2896	}
2897	next_after_fail106:;
2898	}
2899	}
2900	break;
2901	}
2902	default:;
2903	}
2904	break;
2905	}
2906	default:;
2907	}
2908	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2909	{
2910	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2911	{
2912	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 2912, __FUNCTION__)))));
2913	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2914	{
2915	case LSHIFT_EXPR:
2916	{
2917	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 2917, __FUNCTION__)))));
2918	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 2918, __FUNCTION__)))));
2919	if (integer_onep (_q30))
2920	{
2921	{
2922	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2923	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
2924	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2924);
2925	{
2926	res_ops[0] = captures[0];
2927	res_ops[1] = captures[1];
2928	res_ops[2] = captures[2];
2929	return true;
2930	}
2931	next_after_fail107:;
2932	}
2933	}
2934	break;
2935	}
2936	default:;
2937	}
2938	break;
2939	}
2940	default:;
2941	}
2942	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2943	{
2944	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2945	{
2946	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 2946, __FUNCTION__)))));
2947	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2948	{
2949	case LSHIFT_EXPR:
2950	{
2951	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 2951, __FUNCTION__)))));
2952	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 2952, __FUNCTION__)))));
2953	if (integer_onep (_q40))
2954	{
2955	{
2956	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2957	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
2958	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2958);
2959	{
2960	res_ops[0] = captures[0];
2961	res_ops[1] = captures[1];
2962	res_ops[2] = captures[2];
2963	return true;
2964	}
2965	next_after_fail108:;
2966	}
2967	}
2968	break;
2969	}
2970	default:;
2971	}
2972	break;
2973	}
2974	default:;
2975	}
2976	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2977	{
2978	case LSHIFT_EXPR:
2979	{
2980	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 2980, __FUNCTION__)))));
2981	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 2981, __FUNCTION__)))));
2982	if (integer_onep (_q20))
2983	{
2984	{
2985	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2986	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q21, _p1, _q20 };
2987	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2987);
2988	{
2989	res_ops[0] = captures[0];
2990	res_ops[1] = captures[1];
2991	res_ops[2] = captures[2];
2992	return true;
2993	}
2994	next_after_fail109:;
2995	}
2996	}
2997	break;
2998	}
2999	default:;
3000	}
3001	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3002	{
3003	case LSHIFT_EXPR:
3004	{
3005	tree _q30 = TREE_OPERAND (_p1, 0)(((const_cast<tree> (tree_operand_check ((_p1), (0), "generic-match.cc" , 3005, __FUNCTION__)))));
3006	tree _q31 = TREE_OPERAND (_p1, 1)(((const_cast<tree> (tree_operand_check ((_p1), (1), "generic-match.cc" , 3006, __FUNCTION__)))));
3007	if (integer_onep (_q30))
3008	{
3009	{
3010	/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3011	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q31, _p0, _q30 };
3012	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__3012);
3013	{
3014	res_ops[0] = captures[0];
3015	res_ops[1] = captures[1];
3016	res_ops[2] = captures[2];
3017	return true;
3018	}
3019	next_after_fail110:;
3020	}
3021	}
3022	break;
3023	}
3024	default:;
3025	}
3026	break;
3027	}
3028	case BIT_NOT_EXPR:
3029	{
3030	tree _p0 = TREE_OPERAND (t, 0)(((const_cast<tree> (tree_operand_check ((t), (0), "generic-match.cc" , 3030, __FUNCTION__)))));
3031	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
3032	{
3033	case BIT_XOR_EXPR:
3034	{
3035	tree _q20 = TREE_OPERAND (_p0, 0)(((const_cast<tree> (tree_operand_check ((_p0), (0), "generic-match.cc" , 3035, __FUNCTION__)))));
3036	tree _q21 = TREE_OPERAND (_p0, 1)(((const_cast<tree> (tree_operand_check ((_p0), (1), "generic-match.cc" , 3036, __FUNCTION__)))));
3037	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
3038	{
3039	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3040	{
3041	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 3041, __FUNCTION__)))));
3042	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
3043	{
3044	case LSHIFT_EXPR:
3045	{
3046	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 3046, __FUNCTION__)))));
3047	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 3047, __FUNCTION__)))));
3048	if (integer_onep (_q40))
3049	{
3050	{
3051	/* #line 8382 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3052	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q41, _q21, _q40 };
3053	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8382, __FILE__"generic-match.cc", __LINE__3053);
3054	{
3055	res_ops[0] = captures[0];
3056	res_ops[1] = captures[1];
3057	res_ops[2] = captures[2];
3058	return true;
3059	}
3060	next_after_fail111:;
3061	}
3062	}
3063	break;
3064	}
3065	default:;
3066	}
3067	break;
3068	}
3069	case LSHIFT_EXPR:
3070	{
3071	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 3071, __FUNCTION__)))));
3072	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 3072, __FUNCTION__)))));
3073	if (integer_onep (_q30))
3074	{
3075	{
3076	/* #line 8382 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3077	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _q21, _q30 };
3078	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8382, __FILE__"generic-match.cc", __LINE__3078);
3079	{
3080	res_ops[0] = captures[0];
3081	res_ops[1] = captures[1];
3082	res_ops[2] = captures[2];
3083	return true;
3084	}
3085	next_after_fail112:;
3086	}
3087	}
3088	break;
3089	}
3090	default:;
3091	}
3092	break;
3093	}
3094	default:;
3095	}
3096	{
3097	tree _p0_pops[1];
3098	if (tree_nop_convert (_p0, _p0_pops))
3099	{
3100	tree _q20 = _p0_pops[0];
3101	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
3102	{
3103	case BIT_XOR_EXPR:
3104	{
3105	tree _q30 = TREE_OPERAND (_q20, 0)(((const_cast<tree> (tree_operand_check ((_q20), (0), "generic-match.cc", 3105, __FUNCTION__)))));
3106	tree _q31 = TREE_OPERAND (_q20, 1)(((const_cast<tree> (tree_operand_check ((_q20), (1), "generic-match.cc", 3106, __FUNCTION__)))));
3107	switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
3108	{
3109	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3110	{
3111	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 3111, __FUNCTION__)))));
3112	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
3113	{
3114	case LSHIFT_EXPR:
3115	{
3116	tree _q50 = TREE_OPERAND (_q40, 0)(((const_cast<tree> (tree_operand_check ((_q40), (0), "generic-match.cc", 3116, __FUNCTION__)))));
3117	tree _q51 = TREE_OPERAND (_q40, 1)(((const_cast<tree> (tree_operand_check ((_q40), (1), "generic-match.cc", 3117, __FUNCTION__)))));
3118	if (integer_onep (_q50))
3119	{
3120	{
3121	/* #line 8382 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3122	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q51, _q31, _q50 };
3123	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8382, __FILE__"generic-match.cc", __LINE__3123);
3124	{
3125	res_ops[0] = captures[0];
3126	res_ops[1] = captures[1];
3127	res_ops[2] = captures[2];
3128	return true;
3129	}
3130	next_after_fail113:;
3131	}
3132	}
3133	break;
3134	}
3135	default:;
3136	}
3137	break;
3138	}
3139	case LSHIFT_EXPR:
3140	{
3141	tree _q40 = TREE_OPERAND (_q30, 0)(((const_cast<tree> (tree_operand_check ((_q30), (0), "generic-match.cc", 3141, __FUNCTION__)))));
3142	tree _q41 = TREE_OPERAND (_q30, 1)(((const_cast<tree> (tree_operand_check ((_q30), (1), "generic-match.cc", 3142, __FUNCTION__)))));
3143	if (integer_onep (_q40))
3144	{
3145	{
3146	/* #line 8382 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3147	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _q31, _q40 };
3148	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8382, __FILE__"generic-match.cc", __LINE__3148);
3149	{
3150	res_ops[0] = captures[0];
3151	res_ops[1] = captures[1];
3152	res_ops[2] = captures[2];
3153	return true;
3154	}
3155	next_after_fail114:;
3156	}
3157	}
3158	break;
3159	}
3160	default:;
3161	}
3162	break;
3163	}
3164	default:;
3165	}
3166	}
3167	}
3168	break;
3169	}
3170	default:;
3171	}
3172	return false;
3173	}
3174
3175	static tree
3176	generic_simplify_1 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3177	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3178	, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)))
3179	{
3180	/* #line 428 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3181	if (!ALL_FRACT_MODE_P (TYPE_MODE (type))((((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.cc", 3181, __FUNCTION__) ))->base.code) == VECTOR_TYPE) ? vector_type_mode (type) : (type)->type_common.mode)]) == MODE_FRACT \|\| ((enum mode_class ) mode_class[((((enum tree_code) ((tree_class_check ((type), ( tcc_type), "generic-match.cc", 3181, __FUNCTION__)))->base .code) == VECTOR_TYPE) ? vector_type_mode (type) : (type)-> type_common.mode)]) == MODE_VECTOR_FRACT) \|\| (((enum mode_class ) mode_class[((((enum tree_code) ((tree_class_check ((type), ( tcc_type), "generic-match.cc", 3181, __FUNCTION__)))->base .code) == VECTOR_TYPE) ? vector_type_mode (type) : (type)-> type_common.mode)]) == MODE_UFRACT \|\| ((enum mode_class) mode_class [((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.cc" , 3181, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode (type) : (type)->type_common.mode)]) == MODE_VECTOR_UFRACT ))
3182	&& !integer_zerop (captures[0])
3183	&& (!flag_non_call_exceptionsglobal_options.x_flag_non_call_exceptions \|\| tree_expr_nonzero_p (captures[0]))
3184	)
3185	{
3186	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail115;
3187	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 431, __FILE__"generic-match.cc", __LINE__3187);
3188	{
3189	tree _r;
3190	_r = build_one_cst (type);
3191	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3191, __FUNCTION__ ))->base.side_effects_flag))
3192	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3193	return _r;
3194	}
3195	next_after_fail115:;
3196	}
3197	return NULL_TREE(tree) nullptr;
3198	}
3199
3200	static tree
3201	generic_simplify_2 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3202	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3203	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3204	{
3205	/* #line 5191 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3206	if (! FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 3206, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE) \|\| ((((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 3206, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE \|\| (((enum tree_code) (((contains_struct_check ((captures[0] ), (TS_TYPED), "generic-match.cc", 3206, __FUNCTION__))->typed .type))->base.code) == VECTOR_TYPE)) && (((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [0]), (TS_TYPED), "generic-match.cc", 3206, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 3206, __FUNCTION__ ))->typed.type))->base.code) == REAL_TYPE)))
3207	\|\| ! tree_expr_maybe_nan_p (captures[0])
3208	)
3209	{
3210	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail116;
3211	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5193, __FILE__"generic-match.cc", __LINE__3211);
3212	{
3213	tree _r;
3214	_r = constant_boolean_node (true, type);
3215	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3215, __FUNCTION__ ))->base.side_effects_flag))
3216	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3217	return _r;
3218	}
3219	next_after_fail116:;
3220	}
3221	else
3222	{
3223	/* #line 5194 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3224	if (cmp != EQ_EXPR
3225	&& (! FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 3225, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE) \|\| ((((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 3225, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE \|\| (((enum tree_code) (((contains_struct_check ((captures[0] ), (TS_TYPED), "generic-match.cc", 3225, __FUNCTION__))->typed .type))->base.code) == VECTOR_TYPE)) && (((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [0]), (TS_TYPED), "generic-match.cc", 3225, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 3225, __FUNCTION__ ))->typed.type))->base.code) == REAL_TYPE)))
3226	\|\| ! flag_trapping_mathglobal_options.x_flag_trapping_math)
3227	)
3228	{
3229	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail117;
3230	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5198, __FILE__"generic-match.cc", __LINE__3230);
3231	{
3232	tree res_op0;
3233	res_op0 = unshare_expr (captures[0]);
3234	tree res_op1;
3235	res_op1 = captures[0];
3236	tree _r;
3237	_r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
3238	return _r;
3239	}
3240	next_after_fail117:;
3241	}
3242	}
3243	return NULL_TREE(tree) nullptr;
3244	}
3245
3246	static tree
3247	generic_simplify_3 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3248	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3249	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3250	{
3251	{
3252	/* #line 4745 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3253	tree from_type = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 3253, __FUNCTION__))->typed.type), to_type = TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 3253, __FUNCTION__))->typed.type);
3254	/* #line 4746 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3255	if (types_match (from_type, to_type)
3256	\|\| (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3256, __FUNCTION__))->base.u.bits.unsigned_flag)
3257	&& !TYPE_UNSIGNED (to_type)((tree_class_check ((to_type), (tcc_type), "generic-match.cc" , 3257, __FUNCTION__))->base.u.bits.unsigned_flag)
3258	&& TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3258, __FUNCTION__))->type_common.precision) == TYPE_PRECISION (to_type)((tree_class_check ((to_type), (tcc_type), "generic-match.cc" , 3258, __FUNCTION__))->type_common.precision)
3259	&& integer_zerop (captures[1])
3260	&& (cmp == LT_EXPR \|\| cmp == GE_EXPR))
3261	)
3262	{
3263	{
3264	/* #line 4753 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3265	wi::overflow_type overflow = wi::OVF_NONE;
3266	enum tree_code code, cmp_code = cmp;
3267	wide_int real_c1;
3268	wide_int c1 = wi::to_wide (captures[1]);
3269	wide_int c2 = wi::to_wide (captures[2]);
3270	wide_int c3 = wi::to_wide (captures[3]);
3271	signop sgn = TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3271, __FUNCTION__))->base.u.bits.unsigned_flag));
3272	if (!types_match (from_type, to_type))
3273	{
3274	if (cmp_code == LT_EXPR)
3275	cmp_code = GT_EXPR;
3276	if (cmp_code == GE_EXPR)
3277	cmp_code = LE_EXPR;
3278	c1 = wi::max_value (to_type);
3279	}
3280	if (op == PLUS_EXPR)
3281	real_c1 = wi::sub (c3, c2, sgn, &overflow);
3282	else
3283	real_c1 = wi::add (c3, c2, sgn, &overflow);
3284	code = cmp_code;
3285	if (!overflow \|\| !TYPE_OVERFLOW_UNDEFINED (from_type)((((enum tree_code) (from_type)->base.code) == POINTER_TYPE \|\| ((enum tree_code) (from_type)->base.code) == REFERENCE_TYPE ) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check ((from_type), "generic-match.cc", 3285, __FUNCTION__))->base .u.bits.unsigned_flag && !global_options.x_flag_wrapv && !global_options.x_flag_trapv)))
3286	{
3287	if (!wi::cmp (wi::sub (real_c1, 1, sgn, &overflow), c1, sgn)
3288	&& !overflow)
3289	{
3290	if (cmp_code == LE_EXPR)
3291	code = LT_EXPR;
3292	if (cmp_code == GT_EXPR)
3293	code = GE_EXPR;
3294	}
3295	if (!wi::cmp (wi::add (real_c1, 1, sgn, &overflow), c1, sgn)
3296	&& !overflow)
3297	{
3298	if (cmp_code == LT_EXPR)
3299	code = LE_EXPR;
3300	if (cmp_code == GE_EXPR)
3301	code = GT_EXPR;
3302	}
3303	if (code != cmp_code \|\| !wi::cmp (real_c1, c1, sgn))
3304	{
3305	if (cmp_code == LT_EXPR \|\| cmp_code == LE_EXPR)
3306	code = MIN_EXPR;
3307	if (cmp_code == GT_EXPR \|\| cmp_code == GE_EXPR)
3308	code = MAX_EXPR;
3309	}
3310	}
3311	/* #line 4817 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3312	if (code == MAX_EXPR
3313	)
3314	{
3315	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3315, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail118;
3316	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3316, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail118;
3317	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3317, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail118;
3318	if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.cc", 3318, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail118;
3319	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail118;
3320	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4818, __FILE__"generic-match.cc", __LINE__3320);
3321	{
3322	tree res_op0;
3323	{
3324	tree _o1[2], _r1;
3325	_o1[0] = captures[0];
3326	_o1[1] = wide_int_to_tree (from_type, real_c1);
3327	_r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3327, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
3328	res_op0 = _r1;
3329	}
3330	tree res_op1;
3331	res_op1 = wide_int_to_tree (from_type, c2);
3332	tree _r;
3333	_r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3334	return _r;
3335	}
3336	next_after_fail118:;
3337	}
3338	else
3339	{
3340	/* #line 4820 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3341	if (code == MIN_EXPR
3342	)
3343	{
3344	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3344, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail119;
3345	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3345, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail119;
3346	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3346, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail119;
3347	if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.cc", 3347, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail119;
3348	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail119;
3349	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4821, __FILE__"generic-match.cc", __LINE__3349);
3350	{
3351	tree res_op0;
3352	{
3353	tree _o1[2], _r1;
3354	_o1[0] = captures[0];
3355	_o1[1] = wide_int_to_tree (from_type, real_c1);
3356	_r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3356, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
3357	res_op0 = _r1;
3358	}
3359	tree res_op1;
3360	res_op1 = wide_int_to_tree (from_type, c2);
3361	tree _r;
3362	_r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3363	return _r;
3364	}
3365	next_after_fail119:;
3366	}
3367	}
3368	}
3369	}
3370	}
3371	return NULL_TREE(tree) nullptr;
3372	}
3373
3374	static tree
3375	generic_simplify_4 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3376	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3377	, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)))
3378	{
3379	/* #line 444 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3380	if ((INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE) \|\| VECTOR_INTEGER_TYPE_P (type)((((enum tree_code) (type)->base.code) == VECTOR_TYPE) && ((enum tree_code) (((contains_struct_check ((type), (TS_TYPED ), "generic-match.cc", 3380, __FUNCTION__))->typed.type))-> base.code) == INTEGER_TYPE))
3381	&& TYPE_OVERFLOW_UNDEFINED (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE \|\| ( (enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? ! global_options.x_flag_wrapv_pointer : (!(any_integral_type_check ((type), "generic-match.cc", 3381, __FUNCTION__))->base.u .bits.unsigned_flag && !global_options.x_flag_wrapv && !global_options.x_flag_trapv))
3382	&& !integer_zerop (captures[0])
3383	&& (!flag_non_call_exceptionsglobal_options.x_flag_non_call_exceptions \|\| tree_expr_nonzero_p (captures[0]))
3384	)
3385	{
3386	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail120;
3387	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 448, __FILE__"generic-match.cc", __LINE__3387);
3388	{
3389	tree _r;
3390	_r = build_minus_one_cst (type);
3391	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3391, __FUNCTION__ ))->base.side_effects_flag))
3392	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3393	return _r;
3394	}
3395	next_after_fail120:;
3396	}
3397	return NULL_TREE(tree) nullptr;
3398	}
3399
3400	static tree
3401	generic_simplify_5 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3402	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
3403	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (icmp)icmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (ncmp)ncmp __attribute__ ((__unused__)))
3404	{
3405	/* #line 5060 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3406	if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE)
3407	\|\| (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE) && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 3407 , __FUNCTION__))->type_common.precision) == 1)
3408	)
3409	{
3410	{
3411	/* #line 5066 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3412	enum tree_code ic = invert_tree_comparison
3413	(cmp, HONOR_NANS (captures[0]));
3414	/* #line 5068 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3415	if (ic == icmp
3416	)
3417	{
3418	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail121;
3419	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5069, __FILE__"generic-match.cc", __LINE__3419);
3420	{
3421	tree res_op0;
3422	res_op0 = captures[0];
3423	tree res_op1;
3424	res_op1 = captures[1];
3425	tree _r;
3426	_r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
3427	return _r;
3428	}
3429	next_after_fail121:;
3430	}
3431	else
3432	{
3433	/* #line 5070 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3434	if (ic == ncmp
3435	)
3436	{
3437	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail122;
3438	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5071, __FILE__"generic-match.cc", __LINE__3438);
3439	{
3440	tree res_op0;
3441	res_op0 = captures[0];
3442	tree res_op1;
3443	res_op1 = captures[1];
3444	tree _r;
3445	_r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
3446	return _r;
3447	}
3448	next_after_fail122:;
3449	}
3450	}
3451	}
3452	}
3453	return NULL_TREE(tree) nullptr;
3454	}
3455
3456	static tree
3457	generic_simplify_6 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3458	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3459	)
3460	{
3461	/* #line 785 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3462	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
3463	)
3464	{
3465	if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 3465, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail123;
3466	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail123;
3467	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 786, __FILE__"generic-match.cc", __LINE__3467);
3468	{
3469	tree res_op0;
3470	res_op0 = unshare_expr (captures[1]);
3471	tree res_op1;
3472	{
3473	tree _o1[2], _r1;
3474	_o1[0] = captures[4];
3475	_o1[1] = captures[1];
3476	_r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3476, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
3477	res_op1 = _r1;
3478	}
3479	tree _r;
3480	_r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
3481	return _r;
3482	}
3483	next_after_fail123:;
3484	}
3485	return NULL_TREE(tree) nullptr;
3486	}
3487
3488	static tree
3489	generic_simplify_7 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3490	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3491	, const combined_fn ARG_UNUSED (cond_op)cond_op __attribute__ ((__unused__)))
3492	{
3493	{
3494	/* #line 7947 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3495	tree op_type = TREE_TYPE (captures[5])((contains_struct_check ((captures[5]), (TS_TYPED), "generic-match.cc" , 3495, __FUNCTION__))->typed.type);
3496	/* #line 7948 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3497	if (inverse_conditions_p (captures[0], captures[2])
3498	&& element_precision (type) == element_precision (op_type)
3499	)
3500	{
3501	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail124;
3502	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 7950, __FILE__"generic-match.cc", __LINE__3502);
3503	{
3504	tree res_op0;
3505	{
3506	tree _o1[4], _r1;
3507	_o1[0] = captures[2];
3508	_o1[1] = captures[3];
3509	_o1[2] = captures[4];
3510	{
3511	tree _o2[1], _r2;
3512	_o2[0] = captures[1];
3513	_r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
3514	_o1[3] = _r2;
3515	}
3516	_r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1])((contains_struct_check ((_o1[1]), (TS_TYPED), "generic-match.cc" , 3516, __FUNCTION__))->typed.type), 4, _o1[0], _o1[1], _o1[2], _o1[3]);
3517	if (!_r1)
3518	goto next_after_fail124;
3519	res_op0 = _r1;
3520	}
3521	tree _r;
3522	_r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3523	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3523, __FUNCTION__ ))->base.side_effects_flag))
3524	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3525	if (TREE_SIDE_EFFECTS (captures[5])((non_type_check ((captures[5]), "generic-match.cc", 3525, __FUNCTION__ ))->base.side_effects_flag))
3526	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
3527	return _r;
3528	}
3529	next_after_fail124:;
3530	}
3531	}
3532	return NULL_TREE(tree) nullptr;
3533	}
3534
3535	static tree
3536	generic_simplify_8 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3537	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3538	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3539	{
3540	{
3541	/* #line 4662 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3542	tree from_type = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 3542, __FUNCTION__))->typed.type);
3543	tree c1_type = TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 3543, __FUNCTION__))->typed.type), c2_type = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 3543, __FUNCTION__))->typed.type);
3544	enum tree_code code = ERROR_MARK;
3545	if (INTEGRAL_TYPE_P (from_type)(((enum tree_code) (from_type)->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (from_type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (from_type)->base.code) == INTEGER_TYPE )
3546	&& int_fits_type_p (captures[2], from_type)
3547	&& (types_match (c1_type, from_type)
3548	\|\| (TYPE_PRECISION (c1_type)((tree_class_check ((c1_type), (tcc_type), "generic-match.cc" , 3548, __FUNCTION__))->type_common.precision) > TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3548, __FUNCTION__))->type_common.precision)
3549	&& (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3549, __FUNCTION__))->base.u.bits.unsigned_flag)
3550	\|\| TYPE_SIGN (c1_type)((signop) ((tree_class_check ((c1_type), (tcc_type), "generic-match.cc" , 3550, __FUNCTION__))->base.u.bits.unsigned_flag)) == TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3550, __FUNCTION__))->base.u.bits.unsigned_flag)))))
3551	&& (types_match (c2_type, from_type)
3552	\|\| (TYPE_PRECISION (c2_type)((tree_class_check ((c2_type), (tcc_type), "generic-match.cc" , 3552, __FUNCTION__))->type_common.precision) > TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3552, __FUNCTION__))->type_common.precision)
3553	&& (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3553, __FUNCTION__))->base.u.bits.unsigned_flag)
3554	\|\| TYPE_SIGN (c2_type)((signop) ((tree_class_check ((c2_type), (tcc_type), "generic-match.cc" , 3554, __FUNCTION__))->base.u.bits.unsigned_flag)) == TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.cc" , 3554, __FUNCTION__))->base.u.bits.unsigned_flag))))))
3555	{
3556	if (cmp != EQ_EXPR)
3557	{
3558	if (wi::to_widest (captures[1]) == (wi::to_widest (captures[2]) - 1))
3559	{
3560	if (cmp == LE_EXPR)
3561	code = LT_EXPR;
3562	if (cmp == GT_EXPR)
3563	code = GE_EXPR;
3564	}
3565	if (wi::to_widest (captures[1]) == (wi::to_widest (captures[2]) + 1))
3566	{
3567	if (cmp == LT_EXPR)
3568	code = LE_EXPR;
3569	if (cmp == GE_EXPR)
3570	code = GT_EXPR;
3571	}
3572	if (code != ERROR_MARK
3573	\|\| wi::to_widest (captures[2]) == wi::to_widest (captures[1]))
3574	{
3575	if (cmp == LT_EXPR \|\| cmp == LE_EXPR)
3576	code = MIN_EXPR;
3577	if (cmp == GT_EXPR \|\| cmp == GE_EXPR)
3578	code = MAX_EXPR;
3579	}
3580	}
3581	else if (int_fits_type_p (captures[1], from_type))
3582	code = EQ_EXPR;
3583	}
3584	/* #line 4713 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3585	if (code == MAX_EXPR
3586	)
3587	{
3588	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3588, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail125;
3589	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3589, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail125;
3590	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3590, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail125;
3591	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail125;
3592	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4714, __FILE__"generic-match.cc", __LINE__3592);
3593	{
3594	tree res_op0;
3595	{
3596	tree _o1[2], _r1;
3597	_o1[0] = captures[0];
3598	{
3599	tree _o2[1], _r2;
3600	_o2[0] = captures[2];
3601	if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc" , 3601, __FUNCTION__))->typed.type) != TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3601, __FUNCTION__))->typed.type))
3602	_r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3602, __FUNCTION__))->typed.type), _o2[0]);
3603	else
3604	_r2 = _o2[0];
3605	_o1[1] = _r2;
3606	}
3607	_r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3607, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
3608	res_op0 = _r1;
3609	}
3610	tree _r;
3611	_r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3612	return _r;
3613	}
3614	next_after_fail125:;
3615	}
3616	else
3617	{
3618	/* #line 4715 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3619	if (code == MIN_EXPR
3620	)
3621	{
3622	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3622, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail126;
3623	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3623, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail126;
3624	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3624, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail126;
3625	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail126;
3626	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4716, __FILE__"generic-match.cc", __LINE__3626);
3627	{
3628	tree res_op0;
3629	{
3630	tree _o1[2], _r1;
3631	_o1[0] = captures[0];
3632	{
3633	tree _o2[1], _r2;
3634	_o2[0] = captures[2];
3635	if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc" , 3635, __FUNCTION__))->typed.type) != TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3635, __FUNCTION__))->typed.type))
3636	_r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3636, __FUNCTION__))->typed.type), _o2[0]);
3637	else
3638	_r2 = _o2[0];
3639	_o1[1] = _r2;
3640	}
3641	_r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3641, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
3642	res_op0 = _r1;
3643	}
3644	tree _r;
3645	_r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3646	return _r;
3647	}
3648	next_after_fail126:;
3649	}
3650	else
3651	{
3652	/* #line 4717 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3653	if (code == EQ_EXPR
3654	)
3655	{
3656	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3656, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail127;
3657	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3657, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail127;
3658	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3658, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail127;
3659	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail127;
3660	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4718, __FILE__"generic-match.cc", __LINE__3660);
3661	{
3662	if (! tree_invariant_p (captures[1])) goto next_after_fail127;
3663	tree res_op0;
3664	{
3665	tree _o1[3], _r1;
3666	{
3667	tree _o2[2], _r2;
3668	_o2[0] = captures[0];
3669	{
3670	tree _o3[1], _r3;
3671	_o3[0] = unshare_expr (captures[1]);
3672	if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.cc" , 3672, __FUNCTION__))->typed.type) != TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc" , 3672, __FUNCTION__))->typed.type))
3673	_r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc" , 3673, __FUNCTION__))->typed.type), _o3[0]);
3674	else
3675	_r3 = _o3[0];
3676	_o2[1] = _r3;
3677	}
3678	_r2 = fold_build2_loc (loc, EQ_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], _o2[0], _o2[1]);
3679	_o1[0] = _r2;
3680	}
3681	{
3682	tree _o2[1], _r2;
3683	_o2[0] = captures[1];
3684	if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc" , 3684, __FUNCTION__))->typed.type) != from_type)
3685	_r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
3686	else
3687	_r2 = _o2[0];
3688	_o1[1] = _r2;
3689	}
3690	{
3691	tree _o2[1], _r2;
3692	_o2[0] = captures[2];
3693	if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc" , 3693, __FUNCTION__))->typed.type) != from_type)
3694	_r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
3695	else
3696	_r2 = _o2[0];
3697	_o1[2] = _r2;
3698	}
3699	_r1 = fold_build3_loc (loc, COND_EXPR, TREE_TYPE (_o1[1])((contains_struct_check ((_o1[1]), (TS_TYPED), "generic-match.cc" , 3699, __FUNCTION__))->typed.type), _o1[0], _o1[1], _o1[2]);
3700	res_op0 = _r1;
3701	}
3702	tree _r;
3703	_r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3704	return _r;
3705	}
3706	next_after_fail127:;
3707	}
3708	}
3709	}
3710	}
3711	return NULL_TREE(tree) nullptr;
3712	}
3713
3714	static tree
3715	generic_simplify_9 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3716	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3717	, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3718	{
3719	if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 3719, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail128;
3720	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail128;
3721	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1607, __FILE__"generic-match.cc", __LINE__3721);
3722	{
3723	tree _r;
3724	_r = captures[0];
3725	return _r;
3726	}
3727	next_after_fail128:;
3728	return NULL_TREE(tree) nullptr;
3729	}
3730
3731	static tree
3732	generic_simplify_10 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3733	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3734	, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)))
3735	{
3736	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail129;
3737	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1402, __FILE__"generic-match.cc", __LINE__3737);
3738	{
3739	tree res_op0;
3740	res_op0 = captures[0];
3741	tree res_op1;
3742	{
3743	tree _o1[1], _r1;
3744	_o1[0] = captures[2];
3745	_r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3745, __FUNCTION__))->typed.type), _o1[0]);
3746	res_op1 = _r1;
3747	}
3748	tree _r;
3749	_r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
3750	return _r;
3751	}
3752	next_after_fail129:;
3753	return NULL_TREE(tree) nullptr;
3754	}
3755
3756	static tree
3757	generic_simplify_11 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3758	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3759	, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3760	{
3761	/* #line 2292 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3762	if (!TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 3762, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 3762, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 3762, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE) && !((((enum tree_code ) (((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 3762, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 3762, __FUNCTION__))->typed .type))->base.code) == REFERENCE_TYPE) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check ((((contains_struct_check ((captures [2]), (TS_TYPED), "generic-match.cc", 3762, __FUNCTION__))-> typed.type)), "generic-match.cc", 3762, __FUNCTION__))->base .u.bits.unsigned_flag \|\| global_options.x_flag_wrapv)) && (global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
3763	)
3764	{
3765	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail130;
3766	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2293, __FILE__"generic-match.cc", __LINE__3766);
3767	{
3768	tree res_op0;
3769	res_op0 = captures[1];
3770	tree res_op1;
3771	res_op1 = captures[3];
3772	tree _r;
3773	_r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3774	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3774, __FUNCTION__ ))->base.side_effects_flag))
3775	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3776	return _r;
3777	}
3778	next_after_fail130:;
3779	}
3780	return NULL_TREE(tree) nullptr;
3781	}
3782
3783	static tree
3784	generic_simplify_12 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3785	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3786	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (bswap)bswap __attribute__ ((__unused__)))
3787	{
3788	{
3789	/* #line 4331 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3790	tree ctype = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 3790, __FUNCTION__))->typed.type);
3791	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail131;
3792	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4332, __FILE__"generic-match.cc", __LINE__3792);
3793	{
3794	tree res_op0;
3795	{
3796	tree _o1[1], _r1;
3797	_o1[0] = captures[1];
3798	if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3798, __FUNCTION__))->typed.type) != ctype)
3799	_r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
3800	else
3801	_r1 = _o1[0];
3802	res_op0 = _r1;
3803	}
3804	tree res_op1;
3805	{
3806	tree _o1[1], _r1;
3807	_o1[0] = captures[2];
3808	if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3808, __FUNCTION__))->typed.type) != ctype)
3809	_r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
3810	else
3811	_r1 = _o1[0];
3812	res_op1 = _r1;
3813	}
3814	tree _r;
3815	_r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
3816	return _r;
3817	}
3818	next_after_fail131:;
3819	}
3820	return NULL_TREE(tree) nullptr;
3821	}
3822
3823	static tree
3824	generic_simplify_13 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3825	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3826	)
3827	{
3828	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail132;
3829	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 7114, __FILE__"generic-match.cc", __LINE__3829);
3830	{
3831	tree _r;
3832	_r = captures[0];
3833	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3833, __FUNCTION__ ))->base.side_effects_flag))
3834	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3835	return _r;
3836	}
3837	next_after_fail132:;
3838	return NULL_TREE(tree) nullptr;
3839	}
3840
3841	static tree
3842	generic_simplify_14 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3843	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3844	, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3845	{
3846	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail133;
3847	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5730, __FILE__"generic-match.cc", __LINE__3847);
3848	{
3849	tree res_op0;
3850	res_op0 = captures[0];
3851	tree res_op1;
3852	res_op1 = captures[1];
3853	tree _r;
3854	_r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3855	return _r;
3856	}
3857	next_after_fail133:;
3858	return NULL_TREE(tree) nullptr;
3859	}
3860
3861	static tree
3862	generic_simplify_15 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3863	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3864	)
3865	{
3866	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail134;
3867	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1412, __FILE__"generic-match.cc", __LINE__3867);
3868	{
3869	tree res_op0;
3870	res_op0 = captures[0];
3871	tree _r;
3872	_r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
3873	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3873, __FUNCTION__ ))->base.side_effects_flag))
3874	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3875	return _r;
3876	}
3877	next_after_fail134:;
3878	return NULL_TREE(tree) nullptr;
3879	}
3880
3881	static tree
3882	generic_simplify_16 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3883	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3884	, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)))
3885	{
3886	/* #line 1862 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3887	if (!CONSTANT_CLASS_P (captures[0])(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code ) (captures[0])->base.code))] == tcc_constant)
3888	)
3889	{
3890	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail135;
3891	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1865, __FILE__"generic-match.cc", __LINE__3891);
3892	{
3893	tree res_op0;
3894	res_op0 = captures[0];
3895	tree res_op1;
3896	{
3897	tree _o1[2], _r1;
3898	_o1[0] = captures[1];
3899	_o1[1] = captures[2];
3900	_r1 = fold_build2_loc (loc, bitop, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3900, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
3901	res_op1 = _r1;
3902	}
3903	tree _r;
3904	_r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
3905	return _r;
3906	}
3907	next_after_fail135:;
3908	}
3909	else
3910	{
3911	{
3912	/* #line 1874 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3913	tree cst1 = const_binop (bitop, type, captures[0], captures[2]);
3914	/* #line 1875 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3915	if (cst1
3916	)
3917	{
3918	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3918, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail136;
3919	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3919, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail136;
3920	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail136;
3921	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1876, __FILE__"generic-match.cc", __LINE__3921);
3922	{
3923	tree res_op0;
3924	res_op0 = captures[1];
3925	tree res_op1;
3926	res_op1 = cst1;
3927	tree _r;
3928	_r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
3929	return _r;
3930	}
3931	next_after_fail136:;
3932	}
3933	else
3934	{
3935	{
3936	/* #line 1877 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3937	tree cst2 = const_binop (bitop, type, captures[1], captures[2]);
3938	/* #line 1878 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3939	if (cst2
3940	)
3941	{
3942	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3942, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail137;
3943	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3943, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail137;
3944	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3944, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail137;
3945	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail137;
3946	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1879, __FILE__"generic-match.cc", __LINE__3946);
3947	{
3948	tree res_op0;
3949	res_op0 = captures[0];
3950	tree res_op1;
3951	res_op1 = cst2;
3952	tree _r;
3953	_r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
3954	return _r;
3955	}
3956	next_after_fail137:;
3957	}
3958	}
3959	}
3960	}
3961	}
3962	return NULL_TREE(tree) nullptr;
3963	}
3964
3965	static tree
3966	generic_simplify_17 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3967	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3968	)
3969	{
3970	if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 3970, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail138;
3971	if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.cc", 3971, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail138;
3972	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail138;
3973	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2640, __FILE__"generic-match.cc", __LINE__3973);
3974	{
3975	tree _r;
3976	_r = captures[0];
3977	return _r;
3978	}
3979	next_after_fail138:;
3980	return NULL_TREE(tree) nullptr;
3981	}
3982
3983	static tree
3984	generic_simplify_18 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3985	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3986	)
3987	{
3988	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail139;
3989	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1417, __FILE__"generic-match.cc", __LINE__3989);
3990	{
3991	tree res_op0;
3992	{
3993	tree _o1[2], _r1;
3994	_o1[0] = captures[1];
3995	_o1[1] = captures[2];
3996	_r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 3996, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
3997	res_op0 = _r1;
3998	}
3999	tree _r;
4000	_r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4001	return _r;
4002	}
4003	next_after_fail139:;
4004	return NULL_TREE(tree) nullptr;
4005	}
4006
4007	static tree
4008	generic_simplify_19 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4009	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
4010	, const combined_fn ARG_UNUSED (cond_op)cond_op __attribute__ ((__unused__)))
4011	{
4012	{
4013	/* #line 7942 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4014	tree op_type = TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc" , 4014, __FUNCTION__))->typed.type);
4015	/* #line 7943 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4016	if (element_precision (type) == element_precision (op_type)
4017	)
4018	{
4019	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail140;
4020	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 7944, __FILE__"generic-match.cc", __LINE__4020);
4021	{
4022	tree res_op0;
4023	{
4024	tree _o1[4], _r1;
4025	_o1[0] = captures[0];
4026	_o1[1] = captures[1];
4027	_o1[2] = captures[2];
4028	{
4029	tree _o2[1], _r2;
4030	_o2[0] = captures[4];
4031	_r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
4032	_o1[3] = _r2;
4033	}
4034	_r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1])((contains_struct_check ((_o1[1]), (TS_TYPED), "generic-match.cc" , 4034, __FUNCTION__))->typed.type), 4, _o1[0], _o1[1], _o1[2], _o1[3]);
4035	if (!_r1)
4036	goto next_after_fail140;
4037	res_op0 = _r1;
4038	}
4039	tree _r;
4040	_r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
4041	if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.cc", 4041, __FUNCTION__ ))->base.side_effects_flag))
4042	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
4043	return _r;
4044	}
4045	next_after_fail140:;
4046	}
4047	}
4048	return NULL_TREE(tree) nullptr;
4049	}
4050
4051	static tree
4052	generic_simplify_20 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4053	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4054	)
4055	{
4056	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail141;
4057	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1422, __FILE__"generic-match.cc", __LINE__4057);
4058	{
4059	tree res_op0;
4060	res_op0 = captures[1];
4061	tree res_op1;
4062	{
4063	tree _o1[1], _r1;
4064	_o1[0] = captures[2];
4065	_r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4065, __FUNCTION__))->typed.type), _o1[0]);
4066	res_op1 = _r1;
4067	}
4068	tree _r;
4069	_r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
4070	return _r;
4071	}
4072	next_after_fail141:;
4073	return NULL_TREE(tree) nullptr;
4074	}
4075
4076	static tree
4077	generic_simplify_21 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4078	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4079	, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4080	{
4081	/* #line 2340 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4082	if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 4082, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[2]) , (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE) \|\| ((((enum tree_code ) (((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 4082, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE \|\| (((enum tree_code) (((contains_struct_check ((captures[2] ), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))->typed .type))->base.code) == VECTOR_TYPE)) && (((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [2]), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__ ))->typed.type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (((contains_struct_check ((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__ ))->typed.type)), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__ ))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [2]), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__ ))->typed.type))->base.code) == INTEGER_TYPE)))
4083	&& (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 4083, __FUNCTION__))->typed .type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 4083, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE ) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check ((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 4083, __FUNCTION__))->typed.type)), "generic-match.cc", 4083 , __FUNCTION__))->base.u.bits.unsigned_flag && !global_options .x_flag_wrapv && !global_options.x_flag_trapv))
4084	\|\| TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), ( TS_TYPED), "generic-match.cc", 4084, __FUNCTION__))->typed .type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 4084, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE ) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check ((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 4084, __FUNCTION__))->typed.type)), "generic-match.cc", 4084 , __FUNCTION__))->base.u.bits.unsigned_flag \|\| global_options .x_flag_wrapv)))
4085	&& (CONSTANT_CLASS_P (captures[2])(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code ) (captures[2])->base.code))] == tcc_constant) \|\| (single_use (captures[1]) && single_use (captures[0])))
4086	&& tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4086, __FUNCTION__))->typed.type), TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4086, __FUNCTION__))->typed.type))
4087	&& tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4087, __FUNCTION__))->typed.type), TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc" , 4087, __FUNCTION__))->typed.type))
4088	)
4089	{
4090	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail142;
4091	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2346, __FILE__"generic-match.cc", __LINE__4091);
4092	{
4093	tree res_op0;
4094	res_op0 = captures[2];
4095	tree res_op1;
4096	res_op1 = build_zero_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 4096, __FUNCTION__))->typed.type));
4097	tree _r;
4098	_r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4099	if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.cc", 4099, __FUNCTION__ ))->base.side_effects_flag))
4100	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
4101	return _r;
4102	}
4103	next_after_fail142:;
4104	}
4105	return NULL_TREE(tree) nullptr;
4106	}
4107
4108	static tree
4109	generic_simplify_22 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4110	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4111	)
4112	{
4113	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail143;
4114	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1427, __FILE__"generic-match.cc", __LINE__4114);
4115	{
4116	tree res_op0;
4117	{
4118	tree _o1[2], _r1;
4119	_o1[0] = captures[1];
4120	_o1[1] = captures[2];
4121	_r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4121, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
4122	res_op0 = _r1;
4123	}
4124	tree _r;
4125	_r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4126	return _r;
4127	}
4128	next_after_fail143:;
4129	return NULL_TREE(tree) nullptr;
4130	}
4131
4132	static tree
4133	generic_simplify_23 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4134	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4135	)
4136	{
4137	/* #line 779 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4138	if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE \|\| ( (enum tree_code) (type)->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (type)->base.code) == INTEGER_TYPE) \|\| VECTOR_INTEGER_TYPE_P (type)((((enum tree_code) (type)->base.code) == VECTOR_TYPE) && ((enum tree_code) (((contains_struct_check ((type), (TS_TYPED ), "generic-match.cc", 4138, __FUNCTION__))->typed.type))-> base.code) == INTEGER_TYPE)
4139	)
4140	{
4141	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail144;
4142	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 780, __FILE__"generic-match.cc", __LINE__4142);
4143	{
4144	tree res_op0;
4145	{
4146	tree _o1[2], _r1;
4147	_o1[0] = captures[0];
4148	_o1[1] = captures[1];
4149	_r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4149, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
4150	res_op0 = _r1;
4151	}
4152	tree _r;
4153	_r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4154	return _r;
4155	}
4156	next_after_fail144:;
4157	}
4158	return NULL_TREE(tree) nullptr;
4159	}
4160
4161	static tree
4162	generic_simplify_24 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4163	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4164	, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4165	{
4166	/* #line 2372 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4167	if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4167, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE) \|\| ((((enum tree_code ) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4167, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE \|\| (((enum tree_code) (((contains_struct_check ((captures[0] ), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))->typed .type))->base.code) == VECTOR_TYPE)) && (((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [0]), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__ ))->typed.type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (((contains_struct_check ((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__ ))->typed.type)), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__ ))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [0]), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__ ))->typed.type))->base.code) == INTEGER_TYPE)))
4168	&& (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4168, __FUNCTION__))->typed .type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4168, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE ) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check ((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4168, __FUNCTION__))->typed.type)), "generic-match.cc", 4168 , __FUNCTION__))->base.u.bits.unsigned_flag && !global_options .x_flag_wrapv && !global_options.x_flag_trapv))
4169	\|\| ((op == EQ_EXPR \|\| op == NE_EXPR)
4170	&& TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4170, __FUNCTION__))->typed .type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4170, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE ) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check ((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4170, __FUNCTION__))->typed.type)), "generic-match.cc", 4170 , __FUNCTION__))->base.u.bits.unsigned_flag \|\| global_options .x_flag_wrapv))))
4171	&& (CONSTANT_CLASS_P (captures[2])(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code ) (captures[2])->base.code))] == tcc_constant) \|\| single_use (captures[1]))
4172	)
4173	{
4174	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail145;
4175	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2377, __FILE__"generic-match.cc", __LINE__4175);
4176	{
4177	tree res_op0;
4178	res_op0 = captures[2];
4179	tree res_op1;
4180	res_op1 = build_zero_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc" , 4180, __FUNCTION__))->typed.type));
4181	tree _r;
4182	_r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4183	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4183, __FUNCTION__ ))->base.side_effects_flag))
4184	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4185	return _r;
4186	}
4187	next_after_fail145:;
4188	}
4189	return NULL_TREE(tree) nullptr;
4190	}
4191
4192	static tree
4193	generic_simplify_25 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4194	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4195	, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (rbitop)rbitop __attribute__ ((__unused__)))
4196	{
4197	if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.cc", 4197, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail146;
4198	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail146;
4199	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1435, __FILE__"generic-match.cc", __LINE__4199);
4200	{
4201	tree res_op0;
4202	res_op0 = captures[1];
4203	tree res_op1;
4204	res_op1 = captures[2];
4205	tree _r;
4206	_r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
4207	return _r;
4208	}
4209	next_after_fail146:;
4210	return NULL_TREE(tree) nullptr;
4211	}
4212
4213	static tree
4214	generic_simplify_26 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4215	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4216	, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4217	{
4218	/* #line 2258 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4219	if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4219, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4219, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4219, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
4220	&& TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4220, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4220, __FUNCTION__)) ->base.u.bits.unsigned_flag)
4221	&& wi::only_sign_bit_p (wi::to_wide (captures[1]))
4222	)
4223	{
4224	{
4225	/* #line 2261 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4226	tree stype = signed_type_for (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4226, __FUNCTION__))->typed.type));
4227	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail147;
4228	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2262, __FILE__"generic-match.cc", __LINE__4228);
4229	{
4230	tree res_op0;
4231	{
4232	tree _o1[1], _r1;
4233	_o1[0] = captures[0];
4234	if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4234, __FUNCTION__))->typed.type) != stype)
4235	_r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
4236	else
4237	_r1 = _o1[0];
4238	res_op0 = _r1;
4239	}
4240	tree res_op1;
4241	{
4242	tree _o1[1], _r1;
4243	_o1[0] = captures[2];
4244	if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4244, __FUNCTION__))->typed.type) != stype)
4245	_r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
4246	else
4247	_r1 = _o1[0];
4248	res_op1 = _r1;
4249	}
4250	tree _r;
4251	_r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4252	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4252, __FUNCTION__ ))->base.side_effects_flag))
4253	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4254	return _r;
4255	}
4256	next_after_fail147:;
4257	}
4258	}
4259	return NULL_TREE(tree) nullptr;
4260	}
4261
4262	static tree
4263	generic_simplify_27 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4264	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4265	)
4266	{
4267	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail148;
4268	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1440, __FILE__"generic-match.cc", __LINE__4268);
4269	{
4270	tree res_op0;
4271	res_op0 = captures[0];
4272	tree res_op1;
4273	res_op1 = captures[1];
4274	tree _r;
4275	_r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
4276	return _r;
4277	}
4278	next_after_fail148:;
4279	return NULL_TREE(tree) nullptr;
4280	}
4281
4282	static tree
4283	generic_simplify_28 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4284	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4285	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (icmp)icmp __attribute__ ((__unused__)))
4286	{
4287	/* #line 5522 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4288	if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4288, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE)
4289	&& ! DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4289, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE) && (((enum mode_class ) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4289, __FUNCTION__ ))->typed.type)), (tcc_type), "generic-match.cc", 4289, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4289, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4289, __FUNCTION__))->typed .type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
4290	)
4291	{
4292	{
4293	/* #line 5524 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4294	tree itype = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4294, __FUNCTION__))->typed.type);
4295	format_helper fmt (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (captures[1])))(real_format_for_mode[(((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check ((captures [1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))-> typed.type)), (tcc_type), "generic-match.cc", 4295, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed .type))->type_common.mode)]) == MODE_DECIMAL_FLOAT) ? (((( (((enum tree_code) ((tree_class_check ((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__ ))->typed.type)), (tcc_type), "generic-match.cc", 4295, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed .type))->type_common.mode)) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check ((captures [1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))-> typed.type)), (tcc_type), "generic-match.cc", 4295, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed .type))->type_common.mode)]) == MODE_FLOAT ? ((((((enum tree_code ) ((tree_class_check ((((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4295, __FUNCTION__)) )->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed .type))->type_common.mode)) - MIN_MODE_FLOAT) : ((fancy_abort ("generic-match.cc", 4295, __FUNCTION__)), 0)]));
4296	const REAL_VALUE_TYPEstruct real_value *cst = TREE_REAL_CST_PTR (captures[1])(&(tree_check ((captures[1]), "generic-match.cc", 4296, __FUNCTION__ , (REAL_CST)))->real_cst.value);
4297	bool exception_p
4298	= real_isnan (cst) && (cst->signalling
4299	\|\| (cmp != EQ_EXPR && cmp != NE_EXPR));
4300	/* #line 5539 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4301	if (fmt.can_represent_integral_type_p (itype) && ! exception_p
4302	)
4303	{
4304	{
4305	/* #line 5540 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4306	signop isign = TYPE_SIGN (itype)((signop) ((tree_class_check ((itype), (tcc_type), "generic-match.cc" , 4306, __FUNCTION__))->base.u.bits.unsigned_flag));
4307	REAL_VALUE_TYPEstruct real_value imin, imax;
4308	real_from_integer (&imin, fmt, wi::min_value (itype), isign);
4309	real_from_integer (&imax, fmt, wi::max_value (itype), isign);
4310	REAL_VALUE_TYPEstruct real_value icst;
4311	if (cmp == GT_EXPR \|\| cmp == GE_EXPR)
4312	real_ceil (&icst, fmt, cst);
4313	else if (cmp == LT_EXPR \|\| cmp == LE_EXPR)
4314	real_floor (&icst, fmt, cst);
4315	else
4316	real_trunc (&icst, fmt, cst);
4317	bool cst_int_p = !real_isnan (cst) && real_identical (&icst, cst);
4318	bool overflow_p = false;
4319	wide_int icst_val
4320	= real_to_integer (&icst, &overflow_p, TYPE_PRECISION (itype)((tree_class_check ((itype), (tcc_type), "generic-match.cc", 4320 , __FUNCTION__))->type_common.precision));
4321	/* #line 5563 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4322	if (real_compare (LT_EXPR, cst, &imin)
4323	)
4324	{
4325	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4325, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail149;
4326	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail149;
4327	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5564, __FILE__"generic-match.cc", __LINE__4327);
4328	{
4329	tree _r;
4330	_r = constant_boolean_node (cmp == GT_EXPR \|\| cmp == GE_EXPR \|\| cmp == NE_EXPR,
4331	type);
4332	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4332, __FUNCTION__ ))->base.side_effects_flag))
4333	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4334	return _r;
4335	}
4336	next_after_fail149:;
4337	}
4338	else
4339	{
4340	/* #line 5566 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4341	if (real_compare (GT_EXPR, cst, &imax)
4342	)
4343	{
4344	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4344, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail150;
4345	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail150;
4346	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5567, __FILE__"generic-match.cc", __LINE__4346);
4347	{
4348	tree _r;
4349	_r = constant_boolean_node (cmp == LT_EXPR \|\| cmp == LE_EXPR \|\| cmp == NE_EXPR,
4350	type);
4351	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4351, __FUNCTION__ ))->base.side_effects_flag))
4352	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4353	return _r;
4354	}
4355	next_after_fail150:;
4356	}
4357	else
4358	{
4359	/* #line 5570 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4360	if (cst_int_p
4361	)
4362	{
4363	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4363, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail151;
4364	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail151;
4365	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5571, __FILE__"generic-match.cc", __LINE__4365);
4366	{
4367	tree res_op0;
4368	res_op0 = captures[0];
4369	tree res_op1;
4370	gcc_assert (!overflow_p)((void)(!(!overflow_p) ? fancy_abort ("generic-match.cc", 4370 , __FUNCTION__), 0 : 0)); res_op1 =
4371	wide_int_to_tree (itype, icst_val);
4372	tree _r;
4373	_r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4374	return _r;
4375	}
4376	next_after_fail151:;
4377	}
4378	else
4379	{
4380	/* #line 5577 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4381	if (cmp == EQ_EXPR \|\| cmp == NE_EXPR
4382	)
4383	{
4384	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4384, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail152;
4385	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail152;
4386	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5578, __FILE__"generic-match.cc", __LINE__4386);
4387	{
4388	tree _r;
4389	_r = constant_boolean_node (cmp == NE_EXPR, type);
4390	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4390, __FUNCTION__ ))->base.side_effects_flag))
4391	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4392	return _r;
4393	}
4394	next_after_fail152:;
4395	}
4396	else
4397	{
4398	{
4399	/* #line 5580 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4400	gcc_checking_assert (!overflow_p)((void)(!(!overflow_p) ? fancy_abort ("generic-match.cc", 4400 , __FUNCTION__), 0 : 0));
4401	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4401, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail153;
4402	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail153;
4403	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5584, __FILE__"generic-match.cc", __LINE__4403);
4404	{
4405	tree res_op0;
4406	res_op0 = captures[0];
4407	tree res_op1;
4408	res_op1 = wide_int_to_tree (itype, icst_val);
4409	tree _r;
4410	_r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
4411	return _r;
4412	}
4413	next_after_fail153:;
4414	}
4415	}
4416	}
4417	}
4418	}
4419	}
4420	}
4421	}
4422	}
4423	return NULL_TREE(tree) nullptr;
4424	}
4425
4426	static tree
4427	generic_simplify_29 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4428	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4429	, const combined_fn ARG_UNUSED (POW)POW __attribute__ ((__unused__)))
4430	{
4431	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail154;
4432	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6705, __FILE__"generic-match.cc", __LINE__4432);
4433	{
4434	tree _r;
4435	_r = captures[0];
4436	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4436, __FUNCTION__ ))->base.side_effects_flag))
4437	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4438	return _r;
4439	}
4440	next_after_fail154:;
4441	return NULL_TREE(tree) nullptr;
4442	}
4443
4444	static tree
4445	generic_simplify_30 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4446	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4447	, const enum tree_code ARG_UNUSED (minmax)minmax __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (out)out __attribute__ ((__unused__)))
4448	{
4449	/* #line 3535 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4450	if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4450, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE) \|\| ((((enum tree_code ) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4450, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE \|\| (((enum tree_code) (((contains_struct_check ((captures[0] ), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))->typed .type))->base.code) == VECTOR_TYPE)) && (((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [0]), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__ ))->typed.type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (((contains_struct_check ((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__ ))->typed.type)), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__ ))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [0]), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__ ))->typed.type))->base.code) == INTEGER_TYPE)))
4451	)
4452	{
4453	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail155;
4454	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3536, __FILE__"generic-match.cc", __LINE__4454);
4455	{
4456	tree res_op0;
4457	res_op0 = captures[0];
4458	tree res_op1;
4459	res_op1 = captures[1];
4460	tree _r;
4461	_r = fold_build2_loc (loc, out, type, res_op0, res_op1);
4462	return _r;
4463	}
4464	next_after_fail155:;
4465	}
4466	return NULL_TREE(tree) nullptr;
4467	}
4468
4469	static tree
4470	generic_simplify_31 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4471	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4472	, const enum tree_code ARG_UNUSED (eqne)eqne __attribute__ ((__unused__)))
4473	{
4474	/* #line 2599 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4475	if (eqne == EQ_EXPR
4476	)
4477	{
4478	if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 4478, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail156;
4479	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail156;
4480	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2600, __FILE__"generic-match.cc", __LINE__4480);
4481	{
4482	tree _r;
4483	_r = constant_boolean_node (false, type);
4484	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4484, __FUNCTION__ ))->base.side_effects_flag))
4485	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4486	return _r;
4487	}
4488	next_after_fail156:;
4489	}
4490	else
4491	{
4492	/* #line 2601 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4493	if (eqne == NE_EXPR
4494	)
4495	{
4496	if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 4496, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail157;
4497	if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.cc", 4497, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail157;
4498	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail157;
4499	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2602, __FILE__"generic-match.cc", __LINE__4499);
4500	{
4501	tree _r;
4502	_r = captures[0];
4503	return _r;
4504	}
4505	next_after_fail157:;
4506	}
4507	}
4508	return NULL_TREE(tree) nullptr;
4509	}
4510
4511	static tree
4512	generic_simplify_32 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4513	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4514	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4515	{
4516	/* #line 5737 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4517	if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4517, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4517, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 4517, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
4518	&& !(targetm.have_canonicalize_funcptr_for_compare ()
4519	&& ((POINTER_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4519, __FUNCTION__))->typed .type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4519, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE )
4520	&& FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[1])))(((enum tree_code) (((contains_struct_check ((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4520, __FUNCTION__ ))->typed.type)), (TS_TYPED), "generic-match.cc", 4520, __FUNCTION__ ))->typed.type))->base.code) == FUNCTION_TYPE \|\| ((enum tree_code) (((contains_struct_check ((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4520, __FUNCTION__ ))->typed.type)), (TS_TYPED), "generic-match.cc", 4520, __FUNCTION__ ))->typed.type))->base.code) == METHOD_TYPE))
4521	\|\| (POINTER_TYPE_P (TREE_TYPE (captures[3]))(((enum tree_code) (((contains_struct_check ((captures[3]), ( TS_TYPED), "generic-match.cc", 4521, __FUNCTION__))->typed .type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc" , 4521, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE )
4522	&& FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[3])))(((enum tree_code) (((contains_struct_check ((((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc", 4522, __FUNCTION__ ))->typed.type)), (TS_TYPED), "generic-match.cc", 4522, __FUNCTION__ ))->typed.type))->base.code) == FUNCTION_TYPE \|\| ((enum tree_code) (((contains_struct_check ((((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc", 4522, __FUNCTION__ ))->typed.type)), (TS_TYPED), "generic-match.cc", 4522, __FUNCTION__ ))->typed.type))->base.code) == METHOD_TYPE))))
4523	&& single_use (captures[0])
4524	)
4525	{
4526	/* #line 5746 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4527	if (TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4527, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4527, __FUNCTION__)) ->type_common.precision) == TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4527, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4527, __FUNCTION__)) ->type_common.precision)
4528	&& (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4529	\|\| captures[2] != captures[3])
4530	&& (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4530, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4530, __FUNCTION__)) ->base.u.bits.unsigned_flag) == TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4530, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4530, __FUNCTION__)) ->base.u.bits.unsigned_flag)
4531	\|\| cmp == NE_EXPR
4532	\|\| cmp == EQ_EXPR)
4533	&& !POINTER_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4533, __FUNCTION__))->typed .type))->base.code) == POINTER_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4533, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE )
4534	&& (TREE_CODE (TREE_TYPE (captures[1]))((enum tree_code) (((contains_struct_check ((captures[1]), (TS_TYPED ), "generic-match.cc", 4534, __FUNCTION__))->typed.type))-> base.code) != BOOLEAN_TYPE
4535	\|\| TREE_CODE (TREE_TYPE (captures[3]))((enum tree_code) (((contains_struct_check ((captures[3]), (TS_TYPED ), "generic-match.cc", 4535, __FUNCTION__))->typed.type))-> base.code) == BOOLEAN_TYPE)
4536	)
4537	{
4538	/* #line 5761 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4539	if (TREE_CODE (captures[2])((enum tree_code) (captures[2])->base.code) == INTEGER_CST
4540	)
4541	{
4542	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4542, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail158;
4543	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail158;
4544	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5762, __FILE__"generic-match.cc", __LINE__4544);
4545	{
4546	tree res_op0;
4547	res_op0 = captures[1];
4548	tree res_op1;
4549	res_op1 = force_fit_type (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4549, __FUNCTION__))->typed.type), wi::to_widest (captures[2]), 0,
4550	TREE_OVERFLOW (captures[2])((tree_class_check ((captures[2]), (tcc_constant), "generic-match.cc" , 4550, __FUNCTION__))->base.public_flag));
4551	tree _r;
4552	_r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4553	return _r;
4554	}
4555	next_after_fail158:;
4556	}
4557	else
4558	{
4559	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail159;
4560	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5764, __FILE__"generic-match.cc", __LINE__4560);
4561	{
4562	tree res_op0;
4563	res_op0 = captures[1];
4564	tree res_op1;
4565	{
4566	tree _o1[1], _r1;
4567	_o1[0] = captures[2];
4568	if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4568, __FUNCTION__))->typed.type) != TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.cc" , 4568, __FUNCTION__))->typed.type))
4569	_r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.cc" , 4569, __FUNCTION__))->typed.type), _o1[0]);
4570	else
4571	_r1 = _o1[0];
4572	res_op1 = _r1;
4573	}
4574	tree _r;
4575	_r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4576	return _r;
4577	}
4578	next_after_fail159:;
4579	}
4580	}
4581	else
4582	{
4583	/* #line 5766 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4584	if (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4584, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4584, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4584, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4584, __FUNCTION__)) ->type_common.precision)
4585	)
4586	{
4587	/* #line 5768 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4588	if ((cmp == EQ_EXPR \|\| cmp == NE_EXPR
4589	\|\| TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4589, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4589, __FUNCTION__)) ->base.u.bits.unsigned_flag) == TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4589, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4589, __FUNCTION__)) ->base.u.bits.unsigned_flag)
4590	\|\| (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4590, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4590, __FUNCTION__)) ->base.u.bits.unsigned_flag)
4591	&& TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4591, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4591, __FUNCTION__)) ->base.u.bits.unsigned_flag)))
4592	&& (types_match (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc" , 4592, __FUNCTION__))->typed.type), TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4592, __FUNCTION__))->typed.type))
4593	\|\| ((TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4593, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4593, __FUNCTION__)) ->type_common.precision)
4594	>= TYPE_PRECISION (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), ( TS_TYPED), "generic-match.cc", 4594, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4594, __FUNCTION__)) ->type_common.precision))
4595	&& (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4595, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4595, __FUNCTION__)) ->base.u.bits.unsigned_flag)
4596	== TYPE_UNSIGNED (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), ( TS_TYPED), "generic-match.cc", 4596, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4596, __FUNCTION__)) ->base.u.bits.unsigned_flag)))
4597	\|\| (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4598	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4598, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4598, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4598, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
4599	&& int_fits_type_p (captures[3], TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4599, __FUNCTION__))->typed.type))))
4600	)
4601	{
4602	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail160;
4603	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5780, __FILE__"generic-match.cc", __LINE__4603);
4604	{
4605	tree res_op0;
4606	res_op0 = captures[1];
4607	tree res_op1;
4608	{
4609	tree _o1[1], _r1;
4610	_o1[0] = captures[3];
4611	if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4611, __FUNCTION__))->typed.type) != TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.cc" , 4611, __FUNCTION__))->typed.type))
4612	_r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.cc" , 4612, __FUNCTION__))->typed.type), _o1[0]);
4613	else
4614	_r1 = _o1[0];
4615	res_op1 = _r1;
4616	}
4617	tree _r;
4618	_r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4619	return _r;
4620	}
4621	next_after_fail160:;
4622	}
4623	else
4624	{
4625	/* #line 5781 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4626	if (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4627	&& INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4627, __FUNCTION__))->typed .type))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4627, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4627, __FUNCTION__))->typed .type))->base.code) == INTEGER_TYPE)
4628	&& !int_fits_type_p (captures[3], TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4628, __FUNCTION__))->typed.type))
4629	)
4630	{
4631	{
4632	/* #line 5784 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4633	tree min = lower_bound_in_type (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc" , 4633, __FUNCTION__))->typed.type), TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4633, __FUNCTION__))->typed.type));
4634	tree max = upper_bound_in_type (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc" , 4634, __FUNCTION__))->typed.type), TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4634, __FUNCTION__))->typed.type));
4635	bool above = integer_nonzerop (const_binop (LT_EXPR, type, max, captures[3]));
4636	bool below = integer_nonzerop (const_binop (LT_EXPR, type, captures[3], min));
4637	/* #line 5791 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4638	if (above \|\| below
4639	)
4640	{
4641	/* #line 5792 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4642	if (cmp == EQ_EXPR \|\| cmp == NE_EXPR
4643	)
4644	{
4645	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail161;
4646	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5793, __FILE__"generic-match.cc", __LINE__4646);
4647	{
4648	tree _r;
4649	_r = constant_boolean_node (cmp == EQ_EXPR ? false : true, type);
4650	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4650, __FUNCTION__ ))->base.side_effects_flag))
4651	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4652	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4652, __FUNCTION__ ))->base.side_effects_flag))
4653	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4654	return _r;
4655	}
4656	next_after_fail161:;
4657	}
4658	else
4659	{
4660	/* #line 5794 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4661	if (cmp == LT_EXPR \|\| cmp == LE_EXPR
4662	)
4663	{
4664	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail162;
4665	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5795, __FILE__"generic-match.cc", __LINE__4665);
4666	{
4667	tree _r;
4668	_r = constant_boolean_node (above ? true : false, type);
4669	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4669, __FUNCTION__ ))->base.side_effects_flag))
4670	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4671	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4671, __FUNCTION__ ))->base.side_effects_flag))
4672	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4673	return _r;
4674	}
4675	next_after_fail162:;
4676	}
4677	else
4678	{
4679	/* #line 5796 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4680	if (cmp == GT_EXPR \|\| cmp == GE_EXPR
4681	)
4682	{
4683	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail163;
4684	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5797, __FILE__"generic-match.cc", __LINE__4684);
4685	{
4686	tree _r;
4687	_r = constant_boolean_node (above ? false : true, type);
4688	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4688, __FUNCTION__ ))->base.side_effects_flag))
4689	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4690	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4690, __FUNCTION__ ))->base.side_effects_flag))
4691	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4692	return _r;
4693	}
4694	next_after_fail163:;
4695	}
4696	}
4697	}
4698	}
4699	}
4700	}
4701	}
4702	}
4703	}
4704	}
4705	else
4706	{
4707	/* #line 5799 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4708	if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4708, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE) \|\| ((((enum tree_code) ( ((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4708, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE \|\| (((enum tree_code) (((contains_struct_check ((captures[1] ), (TS_TYPED), "generic-match.cc", 4708, __FUNCTION__))->typed .type))->base.code) == VECTOR_TYPE)) && (((enum tree_code ) (((contains_struct_check ((((contains_struct_check ((captures [1]), (TS_TYPED), "generic-match.cc", 4708, __FUNCTION__))-> typed.type)), (TS_TYPED), "generic-match.cc", 4708, __FUNCTION__ ))->typed.type))->base.code) == REAL_TYPE)))
4709	&& (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4709, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE) && (((enum mode_class ) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc", 4709, __FUNCTION__ ))->typed.type)), (tcc_type), "generic-match.cc", 4709, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc", 4709, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 4709, __FUNCTION__))->typed .type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
4710	== DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4710, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE) && (((enum mode_class ) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4710, __FUNCTION__ ))->typed.type)), (tcc_type), "generic-match.cc", 4710, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc", 4710, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[1]) , (TS_TYPED), "generic-match.cc", 4710, __FUNCTION__))->typed .type))->type_common.mode)]) == MODE_DECIMAL_FLOAT)))
4711	&& (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4711, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE) && (((enum mode_class ) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc", 4711, __FUNCTION__ ))->typed.type)), (tcc_type), "generic-match.cc", 4711, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc", 4711, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[0]) , (TS_TYPED), "generic-match.cc", 4711, __FUNCTION__))->typed .type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
4712	== DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[3]))((((enum tree_code) (((contains_struct_check ((captures[3]), ( TS_TYPED), "generic-match.cc", 4712, __FUNCTION__))->typed .type))->base.code) == REAL_TYPE) && (((enum mode_class ) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc", 4712, __FUNCTION__ ))->typed.type)), (tcc_type), "generic-match.cc", 4712, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc", 4712, __FUNCTION__ ))->typed.type)) : (((contains_struct_check ((captures[3]) , (TS_TYPED), "generic-match.cc", 4712, __FUNCTION__))->typed .type))->type_common.mode)]) == MODE_DECIMAL_FLOAT)))
4713	)
4714	{
4715	{
4716	/* #line 5804 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4717	tree type1 = TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc" , 4717, __FUNCTION__))->typed.type);
4718	if (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (type1)((((enum tree_code) (type1)->base.code) == REAL_TYPE) && (((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check ((type1), (tcc_type), "generic-match.cc", 4718, __FUNCTION__ )))->base.code) == VECTOR_TYPE) ? vector_type_mode (type1) : (type1)->type_common.mode)]) == MODE_DECIMAL_FLOAT)))
4719	{
4720	REAL_VALUE_TYPEstruct real_value orig = TREE_REAL_CST (captures[3])(*(&(tree_check ((captures[3]), "generic-match.cc", 4720, __FUNCTION__, (REAL_CST)))->real_cst.value));
4721	if (TYPE_PRECISION (type1)((tree_class_check ((type1), (tcc_type), "generic-match.cc", 4721 , __FUNCTION__))->type_common.precision) > TYPE_PRECISION (float_type_node)((tree_class_check ((global_trees[TI_FLOAT_TYPE]), (tcc_type) , "generic-match.cc", 4721, __FUNCTION__))->type_common.precision )
4722	&& exact_real_truncate (TYPE_MODE (float_type_node)((((enum tree_code) ((tree_class_check ((global_trees[TI_FLOAT_TYPE ]), (tcc_type), "generic-match.cc", 4722, __FUNCTION__)))-> base.code) == VECTOR_TYPE) ? vector_type_mode (global_trees[TI_FLOAT_TYPE ]) : (global_trees[TI_FLOAT_TYPE])->type_common.mode), &orig))
4723	type1 = float_type_nodeglobal_trees[TI_FLOAT_TYPE];
4724	if (TYPE_PRECISION (type1)((tree_class_check ((type1), (tcc_type), "generic-match.cc", 4724 , __FUNCTION__))->type_common.precision) > TYPE_PRECISION (double_type_node)((tree_class_check ((global_trees[TI_DOUBLE_TYPE]), (tcc_type ), "generic-match.cc", 4724, __FUNCTION__))->type_common.precision )
4725	&& exact_real_truncate (TYPE_MODE (double_type_node)((((enum tree_code) ((tree_class_check ((global_trees[TI_DOUBLE_TYPE ]), (tcc_type), "generic-match.cc", 4725, __FUNCTION__)))-> base.code) == VECTOR_TYPE) ? vector_type_mode (global_trees[TI_DOUBLE_TYPE ]) : (global_trees[TI_DOUBLE_TYPE])->type_common.mode), &orig))
4726	type1 = double_type_nodeglobal_trees[TI_DOUBLE_TYPE];
4727	}
4728	tree newtype
4729	= (TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), ( TS_TYPED), "generic-match.cc", 4729, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4729, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (type1)((tree_class_check ((type1), (tcc_type), "generic-match.cc", 4729 , __FUNCTION__))->type_common.precision)
4730	? TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 4730, __FUNCTION__))->typed.type) : type1);
4731	/* #line 5821 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4732	if (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "generic-match.cc", 4732, __FUNCTION__))->typed .type)), (tcc_type), "generic-match.cc", 4732, __FUNCTION__)) ->type_common.precision) > TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.cc" , 4732, __FUNCTION__))->type_common.precision)
4733	)
4734	{
4735	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail164;
4736	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5822, __FILE__"generic-match.cc", __LINE__4736);
4737	{
4738	tree res_op0;
4739	{
4740	tree _o1[1], _r1;
4741	_o1[0] = captures[1];
4742	if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4742, __FUNCTION__))->typed.type) != newtype)
4743	_r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
4744	else
4745	_r1 = _o1[0];
4746	res_op0 = _r1;
4747	}
4748	tree res_op1;
4749	{
4750	tree _o1[1], _r1;
4751	_o1[0] = captures[3];
4752	if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 4752, __FUNCTION__))->typed.type) != newtype)
4753	_r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
4754	else
4755	_r1 = _o1[0];
4756	res_op1 = _r1;
4757	}
4758	tree _r;
4759	_r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4760	return _r;
4761	}
4762	next_after_fail164:;
4763	}
4764	}
4765	}
4766	}
4767	return NULL_TREE(tree) nullptr;
4768	}
4769
4770	static tree
4771	generic_simplify_33 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4772	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4773	, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4774	{
4775	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail165;
4776	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1453, __FILE__"generic-match.cc", __LINE__4776);
4777	{
4778	tree res_op0;
4779	res_op0 = captures[0];
4780	tree res_op1;
4781	res_op1 = captures[1];
4782	tree _r;
4783	_r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
4784	return _r;
4785	}
4786	next_after_fail165:;
4787	return NULL_TREE(tree) nullptr;
4788	}
4789
4790	static tree
4791	generic_simplify_34 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4792	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4793	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4794	{
4795	/* #line 3551 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4796	if (wi::gt_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
4797	TYPE_SIGN (TREE_TYPE (captures[0]))((signop) ((tree_class_check ((((contains_struct_check ((captures [0]), (TS_TYPED), "generic-match.cc", 4797, __FUNCTION__))-> typed.type)), (tcc_type), "generic-match.cc", 4797, __FUNCTION__ ))->base.u.bits.unsigned_flag)))
4798	)
4799	{
4800	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail166;
4801	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3553, __FILE__"generic-match.cc", __LINE__4801);
4802	{
4803	tree _r;
4804	_r = constant_boolean_node (cmp == NE_EXPR, type);
4805	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4805, __FUNCTION__ ))->base.side_effects_flag))
4806	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4807	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4807, __FUNCTION__ ))->base.side_effects_flag))
4808	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4809	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4809, __FUNCTION__ ))->base.side_effects_flag))
4810	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4811	return _r;
4812	}
4813	next_after_fail166:;
4814	}
4815	else
4816	{
4817	/* #line 3554 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4818	if (wi::lt_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
4819	TYPE_SIGN (TREE_TYPE (captures[0]))((signop) ((tree_class_check ((((contains_struct_check ((captures [0]), (TS_TYPED), "generic-match.cc", 4819, __FUNCTION__))-> typed.type)), (tcc_type), "generic-match.cc", 4819, __FUNCTION__ ))->base.u.bits.unsigned_flag)))
4820	)
4821	{
4822	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail167;
4823	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3556, __FILE__"generic-match.cc", __LINE__4823);
4824	{
4825	tree res_op0;
4826	res_op0 = captures[0];
4827	tree res_op1;
4828	res_op1 = captures[2];
4829	tree _r;
4830	_r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4831	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4831, __FUNCTION__ ))->base.side_effects_flag))
4832	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4833	return _r;
4834	}
4835	next_after_fail167:;
4836	}
4837	}
4838	return NULL_TREE(tree) nullptr;
4839	}
4840
4841	static tree
4842	generic_simplify_35 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4843	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4844	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4845	{
4846	{
4847	/* #line 5829 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4848	poly_int64 off; tree base;
4849	tree addr = (TREE_CODE (captures[0])((enum tree_code) (captures[0])->base.code) == SSA_NAME
4850	? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])(tree_check ((captures[0]), "generic-match.cc", 4850, __FUNCTION__ , (SSA_NAME)))->ssa_name.def_stmt) : captures[0]);
4851	/* #line 5837 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4852	if (SSA_NAME_IS_DEFAULT_DEF (captures[1])(tree_check ((captures[1]), "generic-match.cc", 4852, __FUNCTION__ , (SSA_NAME)))->base.default_def_flag
4853	&& TREE_CODE (SSA_NAME_VAR (captures[1]))((enum tree_code) (((tree_check ((captures[1]), "generic-match.cc" , 4853, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr \|\| ((enum tree_code) ((captures[1])->ssa_name.var )->base.code) == IDENTIFIER_NODE ? (tree) nullptr : (captures [1])->ssa_name.var))->base.code) == PARM_DECL
4854	&& (base = get_base_address (TREE_OPERAND (addr, 0)(((const_cast<tree> (tree_operand_check ((addr), (0), "generic-match.cc", 4854, __FUNCTION__)))))))
4855	&& TREE_CODE (base)((enum tree_code) (base)->base.code) == VAR_DECL
4856	&& auto_var_in_fn_p (base, current_function_decl)
4857	)
4858	{
4859	/* #line 5842 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4860	if (cmp == NE_EXPR
4861	)
4862	{
4863	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4863, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail168;
4864	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail168;
4865	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5843, __FILE__"generic-match.cc", __LINE__4865);
4866	{
4867	tree _r;
4868	_r = constant_boolean_node (true, type);
4869	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4869, __FUNCTION__ ))->base.side_effects_flag))
4870	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4871	return _r;
4872	}
4873	next_after_fail168:;
4874	}
4875	else
4876	{
4877	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4877, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail169;
4878	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail169;
4879	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5844, __FILE__"generic-match.cc", __LINE__4879);
4880	{
4881	tree _r;
4882	_r = constant_boolean_node (false, type);
4883	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4883, __FUNCTION__ ))->base.side_effects_flag))
4884	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4885	return _r;
4886	}
4887	next_after_fail169:;
4888	}
4889	}
4890	else
4891	{
4892	/* #line 5846 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4893	if ((base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0)(((const_cast<tree> (tree_operand_check ((addr), (0), "generic-match.cc", 4893, __FUNCTION__))))), &off))
4894	&& TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF
4895	&& TREE_OPERAND (base, 0)(((const_cast<tree> (tree_operand_check ((base), (0), "generic-match.cc", 4895, __FUNCTION__))))) == captures[1]
4896	)
4897	{
4898	{
4899	/* #line 5849 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4900	off += mem_ref_offset (base).force_shwi ();
4901	/* #line 5850 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4902	if (known_ne (off, 0)(!maybe_eq (off, 0))
4903	)
4904	{
4905	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4905, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail170;
4906	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail170;
4907	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5851, __FILE__"generic-match.cc", __LINE__4907);
4908	{
4909	tree _r;
4910	_r = constant_boolean_node (cmp == NE_EXPR, type);
4911	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4911, __FUNCTION__ ))->base.side_effects_flag))
4912	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4913	return _r;
4914	}
4915	next_after_fail170:;
4916	}
4917	else
4918	{
4919	/* #line 5852 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4920	if (known_eq (off, 0)(!maybe_ne (off, 0))
4921	)
4922	{
4923	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4923, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail171;
4924	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail171;
4925	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5853, __FILE__"generic-match.cc", __LINE__4925);
4926	{
4927	tree _r;
4928	_r = constant_boolean_node (cmp == EQ_EXPR, type);
4929	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4929, __FUNCTION__ ))->base.side_effects_flag))
4930	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4931	return _r;
4932	}
4933	next_after_fail171:;
4934	}
4935	}
4936	}
4937	}
4938	}
4939	}
4940	return NULL_TREE(tree) nullptr;
4941	}
4942
4943	static tree
4944	generic_simplify_36 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4945	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4946	, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4947	{
4948	/* #line 5606 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4949	if (wi::gt_p (wi::to_wide (captures[1]), 0, TYPE_SIGN (TREE_TYPE (captures[1]))((signop) ((tree_class_check ((((contains_struct_check ((captures [1]), (TS_TYPED), "generic-match.cc", 4949, __FUNCTION__))-> typed.type)), (tcc_type), "generic-match.cc", 4949, __FUNCTION__ ))->base.u.bits.unsigned_flag)))
4950	)
4951	{
4952	{
4953	/* #line 5607 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4954	wi::overflow_type ovf;
4955	wide_int prod = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[1]),
4956	TYPE_SIGN (TREE_TYPE (captures[1]))((signop) ((tree_class_check ((((contains_struct_check ((captures [1]), (TS_TYPED), "generic-match.cc", 4956, __FUNCTION__))-> typed.type)), (tcc_type), "generic-match.cc", 4956, __FUNCTION__ ))->base.u.bits.unsigned_flag)), &ovf);
4957	/* #line 5613 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4958	if (ovf
4959	)
4960	{
4961	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4961, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail172;
4962	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4962, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail172;
4963	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail172;
4964	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5614, __FILE__"generic-match.cc", __LINE__4964);
4965	{
4966	tree _r;
4967	_r = constant_boolean_node (wi::lt_p (wi::to_wide (captures[2]), 0,
4968	TYPE_SIGN (TREE_TYPE (captures[2]))((signop) ((tree_class_check ((((contains_struct_check ((captures [2]), (TS_TYPED), "generic-match.cc", 4968, __FUNCTION__))-> typed.type)), (tcc_type), "generic-match.cc", 4968, __FUNCTION__ ))->base.u.bits.unsigned_flag)))
4969	!= (cmp == LT_EXPR \|\| cmp == LE_EXPR), type);
4970	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4970, __FUNCTION__ ))->base.side_effects_flag))
4971	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4972	return _r;
4973	}
4974	next_after_fail172:;
4975	}
4976	else
4977	{
4978	if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4978, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail173;
4979	if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4979, __FUNCTION__ ))->base.side_effects_flag)) goto next_after_fail173;
4980	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail173;
4981	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5617, __FILE__"generic-match.cc", __LINE__4981);
4982	{
4983	tree res_op0;
4984	res_op0 = captures[0];
4985	tree res_op1;
4986	res_op1 = wide_int_to_tree (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 4986, __FUNCTION__))->typed.type), prod);
4987	tree _r;
4988	_r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4989	return _r;
4990	}
4991	next_after_fail173:;
4992	}
4993	}
4994	}
4995	return NULL_TREE(tree) nullptr;
4996	}
4997
4998	static tree
4999	generic_simplify_37 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5000	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5001	)
5002	{
5003	/* #line 2805 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5004	if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.cc", 5004, __FUNCTION__ , (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE )))->base.u.bits.saturating_flag)
5005	)
5006	{
5007	/* #line 2863 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5008	if ((!FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) \|\| (( ((enum tree_code) (type)->base.code) == COMPLEX_TYPE \|\| (( (enum tree_code) (type)->base.code) == VECTOR_TYPE)) && (((enum tree_code) (((contains_struct_check ((type), (TS_TYPED ), "generic-match.cc", 5008, __FUNCTION__))->typed.type))-> base.code) == REAL_TYPE))) \|\| flag_associative_mathglobal_options.x_flag_associative_math)
5009	&& !FIXED_POINT_TYPE_P (type)(((enum tree_code) (type)->base.code) == FIXED_POINT_TYPE)
5010	)
5011	{
5012	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail174;
5013	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2909, __FILE__"generic-match.cc", __LINE__5013);
5014	{
5015	tree res_op0;
5016	res_op0 = captures[1];
5017	tree res_op1;
5018	res_op1 = captures[2];
5019	tree _r;
5020	_r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
5021	if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 5021, __FUNCTION__ ))->base.side_effects_flag))
5022	_r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5023	return _r;
5024	}
5025	next_after_fail174:;
5026	}
5027	}
5028	return NULL_TREE(tree) nullptr;
5029	}
5030
5031	static tree
5032	generic_simplify_38 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5033	tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5034	, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (rop)rop __attribute__ ((__unused__)))
5035	{
5036	/* #line 1544 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5037	if (element_precision (type) <= element_precision (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc" , 5037, __FUNCTION__))->typed.type))
5038	&& element_precision (type) <= element_precision (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc" , 5038, __FUNCTION__))->typed.type))
5039	)
5040	{
5041	if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail175;
5042	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1546, __FILE__"generic-match.cc", __LINE__5042);
5043	{
5044	tree res_op0;
5045	{
5046	tree _o1[2], _r1;
5047	{
5048	tree _o2[1], _r2;
5049	_o2[0] = captures[0];
5050	if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc" , 5050, __FUNCTION__))->typed.type) != type)
5051	_r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
5052	else
5053	_r2 = _o2[0];
5054	_o1[0] = _r2;
5055	}
5056	{
5057	tree _o2[1], _r2;
5058	_o2[0] = captures[1];
5059	if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc" , 5059, __FUNCTION__))->typed.type) != type)
5060	_r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
5061	else
5062	_r2 = _o2[0];
5063	_o1[1] = _r2;
5064	}
5065	_r1 = fold_build2_loc (loc, rop, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc" , 5065, __FUNCTION__))->typed.type), _o1[0], _o1[1]);
5066	res_op0 = _r1;
5067	}
5068	tree _r;
5069	_r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);