1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // <algorithm>
11 
12 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
13 //   requires CopyConstructible<Compare>
14 //   Iter
15 //   is_heap_until(Iter first, Iter last, Compare comp);
16 
17 #include <algorithm>
18 #include <functional>
19 #include <cassert>
20 
test()21 void test()
22 {
23     int i1[] = {0, 0};
24     assert(std::is_heap_until(i1, i1, std::greater<int>()) == i1);
25     assert(std::is_heap_until(i1, i1+1, std::greater<int>()) == i1+1);
26     int i2[] = {0, 1};
27     int i3[] = {1, 0};
28     assert(std::is_heap_until(i1, i1+2, std::greater<int>()) == i1+2);
29     assert(std::is_heap_until(i2, i2+2, std::greater<int>()) == i2+2);
30     assert(std::is_heap_until(i3, i3+2, std::greater<int>()) == i3+1);
31     int i4[] = {0, 0, 0};
32     int i5[] = {0, 0, 1};
33     int i6[] = {0, 1, 0};
34     int i7[] = {0, 1, 1};
35     int i8[] = {1, 0, 0};
36     int i9[] = {1, 0, 1};
37     int i10[] = {1, 1, 0};
38     assert(std::is_heap_until(i4, i4+3, std::greater<int>()) == i4+3);
39     assert(std::is_heap_until(i5, i5+3, std::greater<int>()) == i5+3);
40     assert(std::is_heap_until(i6, i6+3, std::greater<int>()) == i6+3);
41     assert(std::is_heap_until(i7, i7+3, std::greater<int>()) == i7+3);
42     assert(std::is_heap_until(i8, i8+3, std::greater<int>()) == i8+1);
43     assert(std::is_heap_until(i9, i9+3, std::greater<int>()) == i9+1);
44     assert(std::is_heap_until(i10, i10+3, std::greater<int>()) == i10+2);
45     int i11[] = {0, 0, 0, 0};
46     int i12[] = {0, 0, 0, 1};
47     int i13[] = {0, 0, 1, 0};
48     int i14[] = {0, 0, 1, 1};
49     int i15[] = {0, 1, 0, 0};
50     int i16[] = {0, 1, 0, 1};
51     int i17[] = {0, 1, 1, 0};
52     int i18[] = {0, 1, 1, 1};
53     int i19[] = {1, 0, 0, 0};
54     int i20[] = {1, 0, 0, 1};
55     int i21[] = {1, 0, 1, 0};
56     int i22[] = {1, 0, 1, 1};
57     int i23[] = {1, 1, 0, 0};
58     int i24[] = {1, 1, 0, 1};
59     int i25[] = {1, 1, 1, 0};
60     assert(std::is_heap_until(i11, i11+4, std::greater<int>()) == i11+4);
61     assert(std::is_heap_until(i12, i12+4, std::greater<int>()) == i12+4);
62     assert(std::is_heap_until(i13, i13+4, std::greater<int>()) == i13+4);
63     assert(std::is_heap_until(i14, i14+4, std::greater<int>()) == i14+4);
64     assert(std::is_heap_until(i15, i15+4, std::greater<int>()) == i15+3);
65     assert(std::is_heap_until(i16, i16+4, std::greater<int>()) == i16+4);
66     assert(std::is_heap_until(i17, i17+4, std::greater<int>()) == i17+3);
67     assert(std::is_heap_until(i18, i18+4, std::greater<int>()) == i18+4);
68     assert(std::is_heap_until(i19, i19+4, std::greater<int>()) == i19+1);
69     assert(std::is_heap_until(i20, i20+4, std::greater<int>()) == i20+1);
70     assert(std::is_heap_until(i21, i21+4, std::greater<int>()) == i21+1);
71     assert(std::is_heap_until(i22, i22+4, std::greater<int>()) == i22+1);
72     assert(std::is_heap_until(i23, i23+4, std::greater<int>()) == i23+2);
73     assert(std::is_heap_until(i24, i24+4, std::greater<int>()) == i24+2);
74     assert(std::is_heap_until(i25, i25+4, std::greater<int>()) == i25+3);
75     int i26[] = {0, 0, 0, 0, 0};
76     int i27[] = {0, 0, 0, 0, 1};
77     int i28[] = {0, 0, 0, 1, 0};
78     int i29[] = {0, 0, 0, 1, 1};
79     int i30[] = {0, 0, 1, 0, 0};
80     int i31[] = {0, 0, 1, 0, 1};
81     int i32[] = {0, 0, 1, 1, 0};
82     int i33[] = {0, 0, 1, 1, 1};
83     int i34[] = {0, 1, 0, 0, 0};
84     int i35[] = {0, 1, 0, 0, 1};
85     int i36[] = {0, 1, 0, 1, 0};
86     int i37[] = {0, 1, 0, 1, 1};
87     int i38[] = {0, 1, 1, 0, 0};
88     int i39[] = {0, 1, 1, 0, 1};
89     int i40[] = {0, 1, 1, 1, 0};
90     int i41[] = {0, 1, 1, 1, 1};
91     int i42[] = {1, 0, 0, 0, 0};
92     int i43[] = {1, 0, 0, 0, 1};
93     int i44[] = {1, 0, 0, 1, 0};
94     int i45[] = {1, 0, 0, 1, 1};
95     int i46[] = {1, 0, 1, 0, 0};
96     int i47[] = {1, 0, 1, 0, 1};
97     int i48[] = {1, 0, 1, 1, 0};
98     int i49[] = {1, 0, 1, 1, 1};
99     int i50[] = {1, 1, 0, 0, 0};
100     int i51[] = {1, 1, 0, 0, 1};
101     int i52[] = {1, 1, 0, 1, 0};
102     int i53[] = {1, 1, 0, 1, 1};
103     int i54[] = {1, 1, 1, 0, 0};
104     int i55[] = {1, 1, 1, 0, 1};
105     int i56[] = {1, 1, 1, 1, 0};
106     assert(std::is_heap_until(i26, i26+5, std::greater<int>()) == i26+5);
107     assert(std::is_heap_until(i27, i27+5, std::greater<int>()) == i27+5);
108     assert(std::is_heap_until(i28, i28+5, std::greater<int>()) == i28+5);
109     assert(std::is_heap_until(i29, i29+5, std::greater<int>()) == i29+5);
110     assert(std::is_heap_until(i30, i30+5, std::greater<int>()) == i30+5);
111     assert(std::is_heap_until(i31, i31+5, std::greater<int>()) == i31+5);
112     assert(std::is_heap_until(i32, i32+5, std::greater<int>()) == i32+5);
113     assert(std::is_heap_until(i33, i33+5, std::greater<int>()) == i33+5);
114     assert(std::is_heap_until(i34, i34+5, std::greater<int>()) == i34+3);
115     assert(std::is_heap_until(i35, i35+5, std::greater<int>()) == i35+3);
116     assert(std::is_heap_until(i36, i36+5, std::greater<int>()) == i36+4);
117     assert(std::is_heap_until(i37, i37+5, std::greater<int>()) == i37+5);
118     assert(std::is_heap_until(i38, i38+5, std::greater<int>()) == i38+3);
119     assert(std::is_heap_until(i39, i39+5, std::greater<int>()) == i39+3);
120     assert(std::is_heap_until(i40, i40+5, std::greater<int>()) == i40+4);
121     assert(std::is_heap_until(i41, i41+5, std::greater<int>()) == i41+5);
122     assert(std::is_heap_until(i42, i42+5, std::greater<int>()) == i42+1);
123     assert(std::is_heap_until(i43, i43+5, std::greater<int>()) == i43+1);
124     assert(std::is_heap_until(i44, i44+5, std::greater<int>()) == i44+1);
125     assert(std::is_heap_until(i45, i45+5, std::greater<int>()) == i45+1);
126     assert(std::is_heap_until(i46, i46+5, std::greater<int>()) == i46+1);
127     assert(std::is_heap_until(i47, i47+5, std::greater<int>()) == i47+1);
128     assert(std::is_heap_until(i48, i48+5, std::greater<int>()) == i48+1);
129     assert(std::is_heap_until(i49, i49+5, std::greater<int>()) == i49+1);
130     assert(std::is_heap_until(i50, i50+5, std::greater<int>()) == i50+2);
131     assert(std::is_heap_until(i51, i51+5, std::greater<int>()) == i51+2);
132     assert(std::is_heap_until(i52, i52+5, std::greater<int>()) == i52+2);
133     assert(std::is_heap_until(i53, i53+5, std::greater<int>()) == i53+2);
134     assert(std::is_heap_until(i54, i54+5, std::greater<int>()) == i54+3);
135     assert(std::is_heap_until(i55, i55+5, std::greater<int>()) == i55+3);
136     assert(std::is_heap_until(i56, i56+5, std::greater<int>()) == i56+4);
137     int i57[] = {0, 0, 0, 0, 0, 0};
138     int i58[] = {0, 0, 0, 0, 0, 1};
139     int i59[] = {0, 0, 0, 0, 1, 0};
140     int i60[] = {0, 0, 0, 0, 1, 1};
141     int i61[] = {0, 0, 0, 1, 0, 0};
142     int i62[] = {0, 0, 0, 1, 0, 1};
143     int i63[] = {0, 0, 0, 1, 1, 0};
144     int i64[] = {0, 0, 0, 1, 1, 1};
145     int i65[] = {0, 0, 1, 0, 0, 0};
146     int i66[] = {0, 0, 1, 0, 0, 1};
147     int i67[] = {0, 0, 1, 0, 1, 0};
148     int i68[] = {0, 0, 1, 0, 1, 1};
149     int i69[] = {0, 0, 1, 1, 0, 0};
150     int i70[] = {0, 0, 1, 1, 0, 1};
151     int i71[] = {0, 0, 1, 1, 1, 0};
152     int i72[] = {0, 0, 1, 1, 1, 1};
153     int i73[] = {0, 1, 0, 0, 0, 0};
154     int i74[] = {0, 1, 0, 0, 0, 1};
155     int i75[] = {0, 1, 0, 0, 1, 0};
156     int i76[] = {0, 1, 0, 0, 1, 1};
157     int i77[] = {0, 1, 0, 1, 0, 0};
158     int i78[] = {0, 1, 0, 1, 0, 1};
159     int i79[] = {0, 1, 0, 1, 1, 0};
160     int i80[] = {0, 1, 0, 1, 1, 1};
161     int i81[] = {0, 1, 1, 0, 0, 0};
162     int i82[] = {0, 1, 1, 0, 0, 1};
163     int i83[] = {0, 1, 1, 0, 1, 0};
164     int i84[] = {0, 1, 1, 0, 1, 1};
165     int i85[] = {0, 1, 1, 1, 0, 0};
166     int i86[] = {0, 1, 1, 1, 0, 1};
167     int i87[] = {0, 1, 1, 1, 1, 0};
168     int i88[] = {0, 1, 1, 1, 1, 1};
169     int i89[] = {1, 0, 0, 0, 0, 0};
170     int i90[] = {1, 0, 0, 0, 0, 1};
171     int i91[] = {1, 0, 0, 0, 1, 0};
172     int i92[] = {1, 0, 0, 0, 1, 1};
173     int i93[] = {1, 0, 0, 1, 0, 0};
174     int i94[] = {1, 0, 0, 1, 0, 1};
175     int i95[] = {1, 0, 0, 1, 1, 0};
176     int i96[] = {1, 0, 0, 1, 1, 1};
177     int i97[] = {1, 0, 1, 0, 0, 0};
178     int i98[] = {1, 0, 1, 0, 0, 1};
179     int i99[] = {1, 0, 1, 0, 1, 0};
180     int i100[] = {1, 0, 1, 0, 1, 1};
181     int i101[] = {1, 0, 1, 1, 0, 0};
182     int i102[] = {1, 0, 1, 1, 0, 1};
183     int i103[] = {1, 0, 1, 1, 1, 0};
184     int i104[] = {1, 0, 1, 1, 1, 1};
185     int i105[] = {1, 1, 0, 0, 0, 0};
186     int i106[] = {1, 1, 0, 0, 0, 1};
187     int i107[] = {1, 1, 0, 0, 1, 0};
188     int i108[] = {1, 1, 0, 0, 1, 1};
189     int i109[] = {1, 1, 0, 1, 0, 0};
190     int i110[] = {1, 1, 0, 1, 0, 1};
191     int i111[] = {1, 1, 0, 1, 1, 0};
192     int i112[] = {1, 1, 0, 1, 1, 1};
193     int i113[] = {1, 1, 1, 0, 0, 0};
194     int i114[] = {1, 1, 1, 0, 0, 1};
195     int i115[] = {1, 1, 1, 0, 1, 0};
196     int i116[] = {1, 1, 1, 0, 1, 1};
197     int i117[] = {1, 1, 1, 1, 0, 0};
198     int i118[] = {1, 1, 1, 1, 0, 1};
199     int i119[] = {1, 1, 1, 1, 1, 0};
200     assert(std::is_heap_until(i57, i57+6, std::greater<int>()) == i57+6);
201     assert(std::is_heap_until(i58, i58+6, std::greater<int>()) == i58+6);
202     assert(std::is_heap_until(i59, i59+6, std::greater<int>()) == i59+6);
203     assert(std::is_heap_until(i60, i60+6, std::greater<int>()) == i60+6);
204     assert(std::is_heap_until(i61, i61+6, std::greater<int>()) == i61+6);
205     assert(std::is_heap_until(i62, i62+6, std::greater<int>()) == i62+6);
206     assert(std::is_heap_until(i63, i63+6, std::greater<int>()) == i63+6);
207     assert(std::is_heap_until(i64, i64+6, std::greater<int>()) == i64+6);
208     assert(std::is_heap_until(i65, i65+6, std::greater<int>()) == i65+5);
209     assert(std::is_heap_until(i66, i66+6, std::greater<int>()) == i66+6);
210     assert(std::is_heap_until(i67, i67+6, std::greater<int>()) == i67+5);
211     assert(std::is_heap_until(i68, i68+6, std::greater<int>()) == i68+6);
212     assert(std::is_heap_until(i69, i69+6, std::greater<int>()) == i69+5);
213     assert(std::is_heap_until(i70, i70+6, std::greater<int>()) == i70+6);
214     assert(std::is_heap_until(i71, i71+6, std::greater<int>()) == i71+5);
215     assert(std::is_heap_until(i72, i72+6, std::greater<int>()) == i72+6);
216     assert(std::is_heap_until(i73, i73+6, std::greater<int>()) == i73+3);
217     assert(std::is_heap_until(i74, i74+6, std::greater<int>()) == i74+3);
218     assert(std::is_heap_until(i75, i75+6, std::greater<int>()) == i75+3);
219     assert(std::is_heap_until(i76, i76+6, std::greater<int>()) == i76+3);
220     assert(std::is_heap_until(i77, i77+6, std::greater<int>()) == i77+4);
221     assert(std::is_heap_until(i78, i78+6, std::greater<int>()) == i78+4);
222     assert(std::is_heap_until(i79, i79+6, std::greater<int>()) == i79+6);
223     assert(std::is_heap_until(i80, i80+6, std::greater<int>()) == i80+6);
224     assert(std::is_heap_until(i81, i81+6, std::greater<int>()) == i81+3);
225     assert(std::is_heap_until(i82, i82+6, std::greater<int>()) == i82+3);
226     assert(std::is_heap_until(i83, i83+6, std::greater<int>()) == i83+3);
227     assert(std::is_heap_until(i84, i84+6, std::greater<int>()) == i84+3);
228     assert(std::is_heap_until(i85, i85+6, std::greater<int>()) == i85+4);
229     assert(std::is_heap_until(i86, i86+6, std::greater<int>()) == i86+4);
230     assert(std::is_heap_until(i87, i87+6, std::greater<int>()) == i87+5);
231     assert(std::is_heap_until(i88, i88+6, std::greater<int>()) == i88+6);
232     assert(std::is_heap_until(i89, i89+6, std::greater<int>()) == i89+1);
233     assert(std::is_heap_until(i90, i90+6, std::greater<int>()) == i90+1);
234     assert(std::is_heap_until(i91, i91+6, std::greater<int>()) == i91+1);
235     assert(std::is_heap_until(i92, i92+6, std::greater<int>()) == i92+1);
236     assert(std::is_heap_until(i93, i93+6, std::greater<int>()) == i93+1);
237     assert(std::is_heap_until(i94, i94+6, std::greater<int>()) == i94+1);
238     assert(std::is_heap_until(i95, i95+6, std::greater<int>()) == i95+1);
239     assert(std::is_heap_until(i96, i96+6, std::greater<int>()) == i96+1);
240     assert(std::is_heap_until(i97, i97+6, std::greater<int>()) == i97+1);
241     assert(std::is_heap_until(i98, i98+6, std::greater<int>()) == i98+1);
242     assert(std::is_heap_until(i99, i99+6, std::greater<int>()) == i99+1);
243     assert(std::is_heap_until(i100, i100+6, std::greater<int>()) == i100+1);
244     assert(std::is_heap_until(i101, i101+6, std::greater<int>()) == i101+1);
245     assert(std::is_heap_until(i102, i102+6, std::greater<int>()) == i102+1);
246     assert(std::is_heap_until(i103, i103+6, std::greater<int>()) == i103+1);
247     assert(std::is_heap_until(i104, i104+6, std::greater<int>()) == i104+1);
248     assert(std::is_heap_until(i105, i105+6, std::greater<int>()) == i105+2);
249     assert(std::is_heap_until(i106, i106+6, std::greater<int>()) == i106+2);
250     assert(std::is_heap_until(i107, i107+6, std::greater<int>()) == i107+2);
251     assert(std::is_heap_until(i108, i108+6, std::greater<int>()) == i108+2);
252     assert(std::is_heap_until(i109, i109+6, std::greater<int>()) == i109+2);
253     assert(std::is_heap_until(i110, i110+6, std::greater<int>()) == i110+2);
254     assert(std::is_heap_until(i111, i111+6, std::greater<int>()) == i111+2);
255     assert(std::is_heap_until(i112, i112+6, std::greater<int>()) == i112+2);
256     assert(std::is_heap_until(i113, i113+6, std::greater<int>()) == i113+3);
257     assert(std::is_heap_until(i114, i114+6, std::greater<int>()) == i114+3);
258     assert(std::is_heap_until(i115, i115+6, std::greater<int>()) == i115+3);
259     assert(std::is_heap_until(i116, i116+6, std::greater<int>()) == i116+3);
260     assert(std::is_heap_until(i117, i117+6, std::greater<int>()) == i117+4);
261     assert(std::is_heap_until(i118, i118+6, std::greater<int>()) == i118+4);
262     assert(std::is_heap_until(i119, i119+6, std::greater<int>()) == i119+5);
263     int i120[] = {0, 0, 0, 0, 0, 0, 0};
264     int i121[] = {0, 0, 0, 0, 0, 0, 1};
265     int i122[] = {0, 0, 0, 0, 0, 1, 0};
266     int i123[] = {0, 0, 0, 0, 0, 1, 1};
267     int i124[] = {0, 0, 0, 0, 1, 0, 0};
268     int i125[] = {0, 0, 0, 0, 1, 0, 1};
269     int i126[] = {0, 0, 0, 0, 1, 1, 0};
270     int i127[] = {0, 0, 0, 0, 1, 1, 1};
271     int i128[] = {0, 0, 0, 1, 0, 0, 0};
272     int i129[] = {0, 0, 0, 1, 0, 0, 1};
273     int i130[] = {0, 0, 0, 1, 0, 1, 0};
274     int i131[] = {0, 0, 0, 1, 0, 1, 1};
275     int i132[] = {0, 0, 0, 1, 1, 0, 0};
276     int i133[] = {0, 0, 0, 1, 1, 0, 1};
277     int i134[] = {0, 0, 0, 1, 1, 1, 0};
278     int i135[] = {0, 0, 0, 1, 1, 1, 1};
279     int i136[] = {0, 0, 1, 0, 0, 0, 0};
280     int i137[] = {0, 0, 1, 0, 0, 0, 1};
281     int i138[] = {0, 0, 1, 0, 0, 1, 0};
282     int i139[] = {0, 0, 1, 0, 0, 1, 1};
283     int i140[] = {0, 0, 1, 0, 1, 0, 0};
284     int i141[] = {0, 0, 1, 0, 1, 0, 1};
285     int i142[] = {0, 0, 1, 0, 1, 1, 0};
286     int i143[] = {0, 0, 1, 0, 1, 1, 1};
287     int i144[] = {0, 0, 1, 1, 0, 0, 0};
288     int i145[] = {0, 0, 1, 1, 0, 0, 1};
289     int i146[] = {0, 0, 1, 1, 0, 1, 0};
290     int i147[] = {0, 0, 1, 1, 0, 1, 1};
291     int i148[] = {0, 0, 1, 1, 1, 0, 0};
292     int i149[] = {0, 0, 1, 1, 1, 0, 1};
293     int i150[] = {0, 0, 1, 1, 1, 1, 0};
294     int i151[] = {0, 0, 1, 1, 1, 1, 1};
295     int i152[] = {0, 1, 0, 0, 0, 0, 0};
296     int i153[] = {0, 1, 0, 0, 0, 0, 1};
297     int i154[] = {0, 1, 0, 0, 0, 1, 0};
298     int i155[] = {0, 1, 0, 0, 0, 1, 1};
299     int i156[] = {0, 1, 0, 0, 1, 0, 0};
300     int i157[] = {0, 1, 0, 0, 1, 0, 1};
301     int i158[] = {0, 1, 0, 0, 1, 1, 0};
302     int i159[] = {0, 1, 0, 0, 1, 1, 1};
303     int i160[] = {0, 1, 0, 1, 0, 0, 0};
304     int i161[] = {0, 1, 0, 1, 0, 0, 1};
305     int i162[] = {0, 1, 0, 1, 0, 1, 0};
306     int i163[] = {0, 1, 0, 1, 0, 1, 1};
307     int i164[] = {0, 1, 0, 1, 1, 0, 0};
308     int i165[] = {0, 1, 0, 1, 1, 0, 1};
309     int i166[] = {0, 1, 0, 1, 1, 1, 0};
310     int i167[] = {0, 1, 0, 1, 1, 1, 1};
311     int i168[] = {0, 1, 1, 0, 0, 0, 0};
312     int i169[] = {0, 1, 1, 0, 0, 0, 1};
313     int i170[] = {0, 1, 1, 0, 0, 1, 0};
314     int i171[] = {0, 1, 1, 0, 0, 1, 1};
315     int i172[] = {0, 1, 1, 0, 1, 0, 0};
316     int i173[] = {0, 1, 1, 0, 1, 0, 1};
317     int i174[] = {0, 1, 1, 0, 1, 1, 0};
318     int i175[] = {0, 1, 1, 0, 1, 1, 1};
319     int i176[] = {0, 1, 1, 1, 0, 0, 0};
320     int i177[] = {0, 1, 1, 1, 0, 0, 1};
321     int i178[] = {0, 1, 1, 1, 0, 1, 0};
322     int i179[] = {0, 1, 1, 1, 0, 1, 1};
323     int i180[] = {0, 1, 1, 1, 1, 0, 0};
324     int i181[] = {0, 1, 1, 1, 1, 0, 1};
325     int i182[] = {0, 1, 1, 1, 1, 1, 0};
326     int i183[] = {0, 1, 1, 1, 1, 1, 1};
327     int i184[] = {1, 0, 0, 0, 0, 0, 0};
328     int i185[] = {1, 0, 0, 0, 0, 0, 1};
329     int i186[] = {1, 0, 0, 0, 0, 1, 0};
330     int i187[] = {1, 0, 0, 0, 0, 1, 1};
331     int i188[] = {1, 0, 0, 0, 1, 0, 0};
332     int i189[] = {1, 0, 0, 0, 1, 0, 1};
333     int i190[] = {1, 0, 0, 0, 1, 1, 0};
334     int i191[] = {1, 0, 0, 0, 1, 1, 1};
335     int i192[] = {1, 0, 0, 1, 0, 0, 0};
336     int i193[] = {1, 0, 0, 1, 0, 0, 1};
337     int i194[] = {1, 0, 0, 1, 0, 1, 0};
338     int i195[] = {1, 0, 0, 1, 0, 1, 1};
339     int i196[] = {1, 0, 0, 1, 1, 0, 0};
340     int i197[] = {1, 0, 0, 1, 1, 0, 1};
341     int i198[] = {1, 0, 0, 1, 1, 1, 0};
342     int i199[] = {1, 0, 0, 1, 1, 1, 1};
343     int i200[] = {1, 0, 1, 0, 0, 0, 0};
344     int i201[] = {1, 0, 1, 0, 0, 0, 1};
345     int i202[] = {1, 0, 1, 0, 0, 1, 0};
346     int i203[] = {1, 0, 1, 0, 0, 1, 1};
347     int i204[] = {1, 0, 1, 0, 1, 0, 0};
348     int i205[] = {1, 0, 1, 0, 1, 0, 1};
349     int i206[] = {1, 0, 1, 0, 1, 1, 0};
350     int i207[] = {1, 0, 1, 0, 1, 1, 1};
351     int i208[] = {1, 0, 1, 1, 0, 0, 0};
352     int i209[] = {1, 0, 1, 1, 0, 0, 1};
353     int i210[] = {1, 0, 1, 1, 0, 1, 0};
354     int i211[] = {1, 0, 1, 1, 0, 1, 1};
355     int i212[] = {1, 0, 1, 1, 1, 0, 0};
356     int i213[] = {1, 0, 1, 1, 1, 0, 1};
357     int i214[] = {1, 0, 1, 1, 1, 1, 0};
358     int i215[] = {1, 0, 1, 1, 1, 1, 1};
359     int i216[] = {1, 1, 0, 0, 0, 0, 0};
360     int i217[] = {1, 1, 0, 0, 0, 0, 1};
361     int i218[] = {1, 1, 0, 0, 0, 1, 0};
362     int i219[] = {1, 1, 0, 0, 0, 1, 1};
363     int i220[] = {1, 1, 0, 0, 1, 0, 0};
364     int i221[] = {1, 1, 0, 0, 1, 0, 1};
365     int i222[] = {1, 1, 0, 0, 1, 1, 0};
366     int i223[] = {1, 1, 0, 0, 1, 1, 1};
367     int i224[] = {1, 1, 0, 1, 0, 0, 0};
368     int i225[] = {1, 1, 0, 1, 0, 0, 1};
369     int i226[] = {1, 1, 0, 1, 0, 1, 0};
370     int i227[] = {1, 1, 0, 1, 0, 1, 1};
371     int i228[] = {1, 1, 0, 1, 1, 0, 0};
372     int i229[] = {1, 1, 0, 1, 1, 0, 1};
373     int i230[] = {1, 1, 0, 1, 1, 1, 0};
374     int i231[] = {1, 1, 0, 1, 1, 1, 1};
375     int i232[] = {1, 1, 1, 0, 0, 0, 0};
376     int i233[] = {1, 1, 1, 0, 0, 0, 1};
377     int i234[] = {1, 1, 1, 0, 0, 1, 0};
378     int i235[] = {1, 1, 1, 0, 0, 1, 1};
379     int i236[] = {1, 1, 1, 0, 1, 0, 0};
380     int i237[] = {1, 1, 1, 0, 1, 0, 1};
381     int i238[] = {1, 1, 1, 0, 1, 1, 0};
382     int i239[] = {1, 1, 1, 0, 1, 1, 1};
383     int i240[] = {1, 1, 1, 1, 0, 0, 0};
384     int i241[] = {1, 1, 1, 1, 0, 0, 1};
385     int i242[] = {1, 1, 1, 1, 0, 1, 0};
386     int i243[] = {1, 1, 1, 1, 0, 1, 1};
387     int i244[] = {1, 1, 1, 1, 1, 0, 0};
388     int i245[] = {1, 1, 1, 1, 1, 0, 1};
389     int i246[] = {1, 1, 1, 1, 1, 1, 0};
390     assert(std::is_heap_until(i120, i120+7, std::greater<int>()) == i120+7);
391     assert(std::is_heap_until(i121, i121+7, std::greater<int>()) == i121+7);
392     assert(std::is_heap_until(i122, i122+7, std::greater<int>()) == i122+7);
393     assert(std::is_heap_until(i123, i123+7, std::greater<int>()) == i123+7);
394     assert(std::is_heap_until(i124, i124+7, std::greater<int>()) == i124+7);
395     assert(std::is_heap_until(i125, i125+7, std::greater<int>()) == i125+7);
396     assert(std::is_heap_until(i126, i126+7, std::greater<int>()) == i126+7);
397     assert(std::is_heap_until(i127, i127+7, std::greater<int>()) == i127+7);
398     assert(std::is_heap_until(i128, i128+7, std::greater<int>()) == i128+7);
399     assert(std::is_heap_until(i129, i129+7, std::greater<int>()) == i129+7);
400     assert(std::is_heap_until(i130, i130+7, std::greater<int>()) == i130+7);
401     assert(std::is_heap_until(i131, i131+7, std::greater<int>()) == i131+7);
402     assert(std::is_heap_until(i132, i132+7, std::greater<int>()) == i132+7);
403     assert(std::is_heap_until(i133, i133+7, std::greater<int>()) == i133+7);
404     assert(std::is_heap_until(i134, i134+7, std::greater<int>()) == i134+7);
405     assert(std::is_heap_until(i135, i135+7, std::greater<int>()) == i135+7);
406     assert(std::is_heap_until(i136, i136+7, std::greater<int>()) == i136+5);
407     assert(std::is_heap_until(i137, i137+7, std::greater<int>()) == i137+5);
408     assert(std::is_heap_until(i138, i138+7, std::greater<int>()) == i138+6);
409     assert(std::is_heap_until(i139, i139+7, std::greater<int>()) == i139+7);
410     assert(std::is_heap_until(i140, i140+7, std::greater<int>()) == i140+5);
411     assert(std::is_heap_until(i141, i141+7, std::greater<int>()) == i141+5);
412     assert(std::is_heap_until(i142, i142+7, std::greater<int>()) == i142+6);
413     assert(std::is_heap_until(i143, i143+7, std::greater<int>()) == i143+7);
414     assert(std::is_heap_until(i144, i144+7, std::greater<int>()) == i144+5);
415     assert(std::is_heap_until(i145, i145+7, std::greater<int>()) == i145+5);
416     assert(std::is_heap_until(i146, i146+7, std::greater<int>()) == i146+6);
417     assert(std::is_heap_until(i147, i147+7, std::greater<int>()) == i147+7);
418     assert(std::is_heap_until(i148, i148+7, std::greater<int>()) == i148+5);
419     assert(std::is_heap_until(i149, i149+7, std::greater<int>()) == i149+5);
420     assert(std::is_heap_until(i150, i150+7, std::greater<int>()) == i150+6);
421     assert(std::is_heap_until(i151, i151+7, std::greater<int>()) == i151+7);
422     assert(std::is_heap_until(i152, i152+7, std::greater<int>()) == i152+3);
423     assert(std::is_heap_until(i153, i153+7, std::greater<int>()) == i153+3);
424     assert(std::is_heap_until(i154, i154+7, std::greater<int>()) == i154+3);
425     assert(std::is_heap_until(i155, i155+7, std::greater<int>()) == i155+3);
426     assert(std::is_heap_until(i156, i156+7, std::greater<int>()) == i156+3);
427     assert(std::is_heap_until(i157, i157+7, std::greater<int>()) == i157+3);
428     assert(std::is_heap_until(i158, i158+7, std::greater<int>()) == i158+3);
429     assert(std::is_heap_until(i159, i159+7, std::greater<int>()) == i159+3);
430     assert(std::is_heap_until(i160, i160+7, std::greater<int>()) == i160+4);
431     assert(std::is_heap_until(i161, i161+7, std::greater<int>()) == i161+4);
432     assert(std::is_heap_until(i162, i162+7, std::greater<int>()) == i162+4);
433     assert(std::is_heap_until(i163, i163+7, std::greater<int>()) == i163+4);
434     assert(std::is_heap_until(i164, i164+7, std::greater<int>()) == i164+7);
435     assert(std::is_heap_until(i165, i165+7, std::greater<int>()) == i165+7);
436     assert(std::is_heap_until(i166, i166+7, std::greater<int>()) == i166+7);
437     assert(std::is_heap_until(i167, i167+7, std::greater<int>()) == i167+7);
438     assert(std::is_heap_until(i168, i168+7, std::greater<int>()) == i168+3);
439     assert(std::is_heap_until(i169, i169+7, std::greater<int>()) == i169+3);
440     assert(std::is_heap_until(i170, i170+7, std::greater<int>()) == i170+3);
441     assert(std::is_heap_until(i171, i171+7, std::greater<int>()) == i171+3);
442     assert(std::is_heap_until(i172, i172+7, std::greater<int>()) == i172+3);
443     assert(std::is_heap_until(i173, i173+7, std::greater<int>()) == i173+3);
444     assert(std::is_heap_until(i174, i174+7, std::greater<int>()) == i174+3);
445     assert(std::is_heap_until(i175, i175+7, std::greater<int>()) == i175+3);
446     assert(std::is_heap_until(i176, i176+7, std::greater<int>()) == i176+4);
447     assert(std::is_heap_until(i177, i177+7, std::greater<int>()) == i177+4);
448     assert(std::is_heap_until(i178, i178+7, std::greater<int>()) == i178+4);
449     assert(std::is_heap_until(i179, i179+7, std::greater<int>()) == i179+4);
450     assert(std::is_heap_until(i180, i180+7, std::greater<int>()) == i180+5);
451     assert(std::is_heap_until(i181, i181+7, std::greater<int>()) == i181+5);
452     assert(std::is_heap_until(i182, i182+7, std::greater<int>()) == i182+6);
453     assert(std::is_heap_until(i183, i183+7, std::greater<int>()) == i183+7);
454     assert(std::is_heap_until(i184, i184+7, std::greater<int>()) == i184+1);
455     assert(std::is_heap_until(i185, i185+7, std::greater<int>()) == i185+1);
456     assert(std::is_heap_until(i186, i186+7, std::greater<int>()) == i186+1);
457     assert(std::is_heap_until(i187, i187+7, std::greater<int>()) == i187+1);
458     assert(std::is_heap_until(i188, i188+7, std::greater<int>()) == i188+1);
459     assert(std::is_heap_until(i189, i189+7, std::greater<int>()) == i189+1);
460     assert(std::is_heap_until(i190, i190+7, std::greater<int>()) == i190+1);
461     assert(std::is_heap_until(i191, i191+7, std::greater<int>()) == i191+1);
462     assert(std::is_heap_until(i192, i192+7, std::greater<int>()) == i192+1);
463     assert(std::is_heap_until(i193, i193+7, std::greater<int>()) == i193+1);
464     assert(std::is_heap_until(i194, i194+7, std::greater<int>()) == i194+1);
465     assert(std::is_heap_until(i195, i195+7, std::greater<int>()) == i195+1);
466     assert(std::is_heap_until(i196, i196+7, std::greater<int>()) == i196+1);
467     assert(std::is_heap_until(i197, i197+7, std::greater<int>()) == i197+1);
468     assert(std::is_heap_until(i198, i198+7, std::greater<int>()) == i198+1);
469     assert(std::is_heap_until(i199, i199+7, std::greater<int>()) == i199+1);
470     assert(std::is_heap_until(i200, i200+7, std::greater<int>()) == i200+1);
471     assert(std::is_heap_until(i201, i201+7, std::greater<int>()) == i201+1);
472     assert(std::is_heap_until(i202, i202+7, std::greater<int>()) == i202+1);
473     assert(std::is_heap_until(i203, i203+7, std::greater<int>()) == i203+1);
474     assert(std::is_heap_until(i204, i204+7, std::greater<int>()) == i204+1);
475     assert(std::is_heap_until(i205, i205+7, std::greater<int>()) == i205+1);
476     assert(std::is_heap_until(i206, i206+7, std::greater<int>()) == i206+1);
477     assert(std::is_heap_until(i207, i207+7, std::greater<int>()) == i207+1);
478     assert(std::is_heap_until(i208, i208+7, std::greater<int>()) == i208+1);
479     assert(std::is_heap_until(i209, i209+7, std::greater<int>()) == i209+1);
480     assert(std::is_heap_until(i210, i210+7, std::greater<int>()) == i210+1);
481     assert(std::is_heap_until(i211, i211+7, std::greater<int>()) == i211+1);
482     assert(std::is_heap_until(i212, i212+7, std::greater<int>()) == i212+1);
483     assert(std::is_heap_until(i213, i213+7, std::greater<int>()) == i213+1);
484     assert(std::is_heap_until(i214, i214+7, std::greater<int>()) == i214+1);
485     assert(std::is_heap_until(i215, i215+7, std::greater<int>()) == i215+1);
486     assert(std::is_heap_until(i216, i216+7, std::greater<int>()) == i216+2);
487     assert(std::is_heap_until(i217, i217+7, std::greater<int>()) == i217+2);
488     assert(std::is_heap_until(i218, i218+7, std::greater<int>()) == i218+2);
489     assert(std::is_heap_until(i219, i219+7, std::greater<int>()) == i219+2);
490     assert(std::is_heap_until(i220, i220+7, std::greater<int>()) == i220+2);
491     assert(std::is_heap_until(i221, i221+7, std::greater<int>()) == i221+2);
492     assert(std::is_heap_until(i222, i222+7, std::greater<int>()) == i222+2);
493     assert(std::is_heap_until(i223, i223+7, std::greater<int>()) == i223+2);
494     assert(std::is_heap_until(i224, i224+7, std::greater<int>()) == i224+2);
495     assert(std::is_heap_until(i225, i225+7, std::greater<int>()) == i225+2);
496     assert(std::is_heap_until(i226, i226+7, std::greater<int>()) == i226+2);
497     assert(std::is_heap_until(i227, i227+7, std::greater<int>()) == i227+2);
498     assert(std::is_heap_until(i228, i228+7, std::greater<int>()) == i228+2);
499     assert(std::is_heap_until(i229, i229+7, std::greater<int>()) == i229+2);
500     assert(std::is_heap_until(i230, i230+7, std::greater<int>()) == i230+2);
501     assert(std::is_heap_until(i231, i231+7, std::greater<int>()) == i231+2);
502     assert(std::is_heap_until(i232, i232+7, std::greater<int>()) == i232+3);
503     assert(std::is_heap_until(i233, i233+7, std::greater<int>()) == i233+3);
504     assert(std::is_heap_until(i234, i234+7, std::greater<int>()) == i234+3);
505     assert(std::is_heap_until(i235, i235+7, std::greater<int>()) == i235+3);
506     assert(std::is_heap_until(i236, i236+7, std::greater<int>()) == i236+3);
507     assert(std::is_heap_until(i237, i237+7, std::greater<int>()) == i237+3);
508     assert(std::is_heap_until(i238, i238+7, std::greater<int>()) == i238+3);
509     assert(std::is_heap_until(i239, i239+7, std::greater<int>()) == i239+3);
510     assert(std::is_heap_until(i240, i240+7, std::greater<int>()) == i240+4);
511     assert(std::is_heap_until(i241, i241+7, std::greater<int>()) == i241+4);
512     assert(std::is_heap_until(i242, i242+7, std::greater<int>()) == i242+4);
513     assert(std::is_heap_until(i243, i243+7, std::greater<int>()) == i243+4);
514     assert(std::is_heap_until(i244, i244+7, std::greater<int>()) == i244+5);
515     assert(std::is_heap_until(i245, i245+7, std::greater<int>()) == i245+5);
516     assert(std::is_heap_until(i246, i246+7, std::greater<int>()) == i246+6);
517 }
518 
main()519 int main()
520 {
521     test();
522 }
523