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