generic-match.c

Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name generic-match.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -Wno-unused -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/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 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-O3O6I2.plist -x c++ generic-match.c

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