Головна сторінка Огляд Довідка
Реєстрація Увійти
zc
/
tg_windows5.12.6
1
0
Відгалуження 0
Файли Проблеми 0 Запити на злиття 0 Wiki
Гілка: master
Гілки Теги
tg_windows5.12....
/
Telegram
/
ThirdParty
/
range-v3
/
test
/
algorithm
/
is_heap.hpp

is_heap.hpp 80 KB
Постійне посилання Історія Запис

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068 
  1. // Range v3 library
    2. 

  2. //
    3. 

  3. //  Copyright Eric Niebler 2014-present
    4. 

  4. //
    5. 

  5. //  Use, modification and distribution is subject to the
    6. 

  6. //  Boost Software License, Version 1.0. (See accompanying
    7. 

  7. //  file LICENSE_1_0.txt or copy at
    8. 

  8. //  http://www.boost.org/LICENSE_1_0.txt)
    9. 

  9. //
    10. 

  10. // Project home: https://github.com/ericniebler/range-v3
    11. 

  11. //
    12. 

  12. //  Copyright 2005 - 2007 Adobe Systems Incorporated
    13. 

  13. //  Distributed under the MIT License(see accompanying file LICENSE_1_0_0.txt
    14. 

  14. //  or a copy at http://stlab.adobe.com/licenses.html)
    15. 

  15. 

  16. //===----------------------------------------------------------------------===//
    17. 

  17. //
    18. 

  18. //                     The LLVM Compiler Infrastructure
    19. 

  19. //
    20. 

  20. // This file is dual licensed under the MIT and the University of Illinois Open
    21. 

  21. // Source Licenses. See LICENSE.TXT for details.
    22. 

  22. //
    23. 

  23. //===----------------------------------------------------------------------===//
    24. 

  24. 

  25. // Implementation based on the code in libc++
    26. 

  26. //   http://http://libcxx.llvm.org/
    27. 

  27. 

  28. #include <algorithm>
    29. 

  29. #include <range/v3/core.hpp>
    30. 

  30. #include <range/v3/algorithm/heap_algorithm.hpp>
    31. 

  31. #include "../simple_test.hpp"
    32. 

  32. #include "../test_utils.hpp"
    33. 

  33. #include "../test_iterators.hpp"
    34. 

  34. 

  35. void test()
    36. 

  36. {
    37. 

  37. 

  38. #if defined(IS_HEAP_1) || defined(IS_HEAP_2)
    39. 

  39.     auto is_heap = make_testable_1(ranges::is_heap);
    40. 

  40. #endif
    41. 

  41. 

  42. #ifdef IS_HEAP_1
    43. 

  43.     int i1[] = {0, 0};
    44. 

  44.     is_heap(i1, i1).check([&](bool r){ CHECK(r); });
    45. 

  45.     is_heap(i1, i1+1).check([&](bool r){ CHECK(r == (std::is_heap_until(i1, i1+1) == i1+1)); });
    46. 

  46.     int i2[] = {0, 1};
    47. 

  47.     int i3[] = {1, 0};
    48. 

  48.     is_heap(i1, i1+2).check([&](bool r){ CHECK(r == (std::is_heap_until(i1, i1+2) == i1+2)); });
    49. 

  49.     is_heap(i2, i2+2).check([&](bool r){ CHECK(r == (std::is_heap_until(i2, i2+2) == i2+2)); });
    50. 

  50.     is_heap(i3, i3+2).check([&](bool r){ CHECK(r == (std::is_heap_until(i3, i3+2) == i3+2)); });
    51. 

  51.     int i4[] = {0, 0, 0};
    52. 

  52.     int i5[] = {0, 0, 1};
    53. 

  53.     int i6[] = {0, 1, 0};
    54. 

  54.     int i7[] = {0, 1, 1};
    55. 

  55.     int i8[] = {1, 0, 0};
    56. 

  56.     int i9[] = {1, 0, 1};
    57. 

  57.     int i10[] = {1, 1, 0};
    58. 

  58.     is_heap(i4, i4+3).check([&](bool r){ CHECK(r == (std::is_heap_until(i4, i4+3) == i4+3)); });
    59. 

  59.     is_heap(i5, i5+3).check([&](bool r){ CHECK(r == (std::is_heap_until(i5, i5+3) == i5+3)); });
    60. 

  60.     is_heap(i6, i6+3).check([&](bool r){ CHECK(r == (std::is_heap_until(i6, i6+3) == i6+3)); });
    61. 

  61.     is_heap(i7, i7+3).check([&](bool r){ CHECK(r == (std::is_heap_until(i7, i7+3) == i7+3)); });
    62. 

  62.     is_heap(i8, i8+3).check([&](bool r){ CHECK(r == (std::is_heap_until(i8, i8+3) == i8+3)); });
    63. 

  63.     is_heap(i9, i9+3).check([&](bool r){ CHECK(r == (std::is_heap_until(i9, i9+3) == i9+3)); });
    64. 

  64.     is_heap(i10, i10+3).check([&](bool r){ CHECK(r == (std::is_heap_until(i10, i10+3) == i10+3)); });
    65. 

  65.     int i11[] = {0, 0, 0, 0};
    66. 

  66.     int i12[] = {0, 0, 0, 1};
    67. 

  67.     int i13[] = {0, 0, 1, 0};
    68. 

  68.     int i14[] = {0, 0, 1, 1};
    69. 

  69.     int i15[] = {0, 1, 0, 0};
    70. 

  70.     int i16[] = {0, 1, 0, 1};
    71. 

  71.     int i17[] = {0, 1, 1, 0};
    72. 

  72.     int i18[] = {0, 1, 1, 1};
    73. 

  73.     int i19[] = {1, 0, 0, 0};
    74. 

  74.     int i20[] = {1, 0, 0, 1};
    75. 

  75.     int i21[] = {1, 0, 1, 0};
    76. 

  76.     int i22[] = {1, 0, 1, 1};
    77. 

  77.     int i23[] = {1, 1, 0, 0};
    78. 

  78.     int i24[] = {1, 1, 0, 1};
    79. 

  79.     int i25[] = {1, 1, 1, 0};
    80. 

  80.     is_heap(i11, i11+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i11, i11+4) == i11+4)); });
    81. 

  81.     is_heap(i12, i12+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i12, i12+4) == i12+4)); });
    82. 

  82.     is_heap(i13, i13+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i13, i13+4) == i13+4)); });
    83. 

  83.     is_heap(i14, i14+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i14, i14+4) == i14+4)); });
    84. 

  84.     is_heap(i15, i15+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i15, i15+4) == i15+4)); });
    85. 

  85.     is_heap(i16, i16+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i16, i16+4) == i16+4)); });
    86. 

  86.     is_heap(i17, i17+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i17, i17+4) == i17+4)); });
    87. 

  87.     is_heap(i18, i18+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i18, i18+4) == i18+4)); });
    88. 

  88.     is_heap(i19, i19+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i19, i19+4) == i19+4)); });
    89. 

  89.     is_heap(i20, i20+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i20, i20+4) == i20+4)); });
    90. 

  90.     is_heap(i21, i21+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i21, i21+4) == i21+4)); });
    91. 

  91.     is_heap(i22, i22+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i22, i22+4) == i22+4)); });
    92. 

  92.     is_heap(i23, i23+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i23, i23+4) == i23+4)); });
    93. 

  93.     is_heap(i24, i24+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i24, i24+4) == i24+4)); });
    94. 

  94.     is_heap(i25, i25+4).check([&](bool r){ CHECK(r == (std::is_heap_until(i25, i25+4) == i25+4)); });
    95. 

  95.     int i26[] = {0, 0, 0, 0, 0};
    96. 

  96.     int i27[] = {0, 0, 0, 0, 1};
    97. 

  97.     int i28[] = {0, 0, 0, 1, 0};
    98. 

  98.     int i29[] = {0, 0, 0, 1, 1};
    99. 

  99.     int i30[] = {0, 0, 1, 0, 0};
    100. 

  100.     int i31[] = {0, 0, 1, 0, 1};
    101. 

  101.     int i32[] = {0, 0, 1, 1, 0};
    102. 

  102.     int i33[] = {0, 0, 1, 1, 1};
    103. 

  103.     int i34[] = {0, 1, 0, 0, 0};
    104. 

  104.     int i35[] = {0, 1, 0, 0, 1};
    105. 

  105.     int i36[] = {0, 1, 0, 1, 0};
    106. 

  106.     int i37[] = {0, 1, 0, 1, 1};
    107. 

  107.     int i38[] = {0, 1, 1, 0, 0};
    108. 

  108.     int i39[] = {0, 1, 1, 0, 1};
    109. 

  109.     int i40[] = {0, 1, 1, 1, 0};
    110. 

  110.     int i41[] = {0, 1, 1, 1, 1};
    111. 

  111.     int i42[] = {1, 0, 0, 0, 0};
    112. 

  112.     int i43[] = {1, 0, 0, 0, 1};
    113. 

  113.     int i44[] = {1, 0, 0, 1, 0};
    114. 

  114.     int i45[] = {1, 0, 0, 1, 1};
    115. 

  115.     int i46[] = {1, 0, 1, 0, 0};
    116. 

  116.     int i47[] = {1, 0, 1, 0, 1};
    117. 

  117.     int i48[] = {1, 0, 1, 1, 0};
    118. 

  118.     int i49[] = {1, 0, 1, 1, 1};
    119. 

  119.     int i50[] = {1, 1, 0, 0, 0};
    120. 

  120.     int i51[] = {1, 1, 0, 0, 1};
    121. 

  121.     int i52[] = {1, 1, 0, 1, 0};
    122. 

  122.     int i53[] = {1, 1, 0, 1, 1};
    123. 

  123.     int i54[] = {1, 1, 1, 0, 0};
    124. 

  124.     int i55[] = {1, 1, 1, 0, 1};
    125. 

  125.     int i56[] = {1, 1, 1, 1, 0};
    126. 

  126.     is_heap(i26, i26+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i26, i26+5) == i26+5)); });
    127. 

  127.     is_heap(i27, i27+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i27, i27+5) == i27+5)); });
    128. 

  128.     is_heap(i28, i28+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i28, i28+5) == i28+5)); });
    129. 

  129.     is_heap(i29, i29+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i29, i29+5) == i29+5)); });
    130. 

  130.     is_heap(i30, i30+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i30, i30+5) == i30+5)); });
    131. 

  131.     is_heap(i31, i31+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i31, i31+5) == i31+5)); });
    132. 

  132.     is_heap(i32, i32+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i32, i32+5) == i32+5)); });
    133. 

  133.     is_heap(i33, i33+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i33, i33+5) == i33+5)); });
    134. 

  134.     is_heap(i34, i34+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i34, i34+5) == i34+5)); });
    135. 

  135.     is_heap(i35, i35+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i35, i35+5) == i35+5)); });
    136. 

  136.     is_heap(i36, i36+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i36, i36+5) == i36+5)); });
    137. 

  137.     is_heap(i37, i37+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i37, i37+5) == i37+5)); });
    138. 

  138.     is_heap(i38, i38+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i38, i38+5) == i38+5)); });
    139. 

  139.     is_heap(i39, i39+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i39, i39+5) == i39+5)); });
    140. 

  140.     is_heap(i40, i40+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i40, i40+5) == i40+5)); });
    141. 

  141.     is_heap(i41, i41+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i41, i41+5) == i41+5)); });
    142. 

  142.     is_heap(i42, i42+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i42, i42+5) == i42+5)); });
    143. 

  143.     is_heap(i43, i43+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i43, i43+5) == i43+5)); });
    144. 

  144.     is_heap(i44, i44+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i44, i44+5) == i44+5)); });
    145. 

  145.     is_heap(i45, i45+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i45, i45+5) == i45+5)); });
    146. 

  146.     is_heap(i46, i46+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i46, i46+5) == i46+5)); });
    147. 

  147.     is_heap(i47, i47+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i47, i47+5) == i47+5)); });
    148. 

  148.     is_heap(i48, i48+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i48, i48+5) == i48+5)); });
    149. 

  149.     is_heap(i49, i49+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i49, i49+5) == i49+5)); });
    150. 

  150.     is_heap(i50, i50+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i50, i50+5) == i50+5)); });
    151. 

  151.     is_heap(i51, i51+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i51, i51+5) == i51+5)); });
    152. 

  152.     is_heap(i52, i52+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i52, i52+5) == i52+5)); });
    153. 

  153.     is_heap(i53, i53+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i53, i53+5) == i53+5)); });
    154. 

  154.     is_heap(i54, i54+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i54, i54+5) == i54+5)); });
    155. 

  155.     is_heap(i55, i55+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i55, i55+5) == i55+5)); });
    156. 

  156.     is_heap(i56, i56+5).check([&](bool r){ CHECK(r == (std::is_heap_until(i56, i56+5) == i56+5)); });
    157. 

  157.     int i57[] = {0, 0, 0, 0, 0, 0};
    158. 

  158.     int i58[] = {0, 0, 0, 0, 0, 1};
    159. 

  159.     int i59[] = {0, 0, 0, 0, 1, 0};
    160. 

  160.     int i60[] = {0, 0, 0, 0, 1, 1};
    161. 

  161.     int i61[] = {0, 0, 0, 1, 0, 0};
    162. 

  162.     int i62[] = {0, 0, 0, 1, 0, 1};
    163. 

  163.     int i63[] = {0, 0, 0, 1, 1, 0};
    164. 

  164.     int i64[] = {0, 0, 0, 1, 1, 1};
    165. 

  165.     int i65[] = {0, 0, 1, 0, 0, 0};
    166. 

  166.     int i66[] = {0, 0, 1, 0, 0, 1};
    167. 

  167.     int i67[] = {0, 0, 1, 0, 1, 0};
    168. 

  168.     int i68[] = {0, 0, 1, 0, 1, 1};
    169. 

  169.     int i69[] = {0, 0, 1, 1, 0, 0};
    170. 

  170.     int i70[] = {0, 0, 1, 1, 0, 1};
    171. 

  171.     int i71[] = {0, 0, 1, 1, 1, 0};
    172. 

  172.     int i72[] = {0, 0, 1, 1, 1, 1};
    173. 

  173.     int i73[] = {0, 1, 0, 0, 0, 0};
    174. 

  174.     int i74[] = {0, 1, 0, 0, 0, 1};
    175. 

  175.     int i75[] = {0, 1, 0, 0, 1, 0};
    176. 

  176.     int i76[] = {0, 1, 0, 0, 1, 1};
    177. 

  177.     int i77[] = {0, 1, 0, 1, 0, 0};
    178. 

  178.     int i78[] = {0, 1, 0, 1, 0, 1};
    179. 

  179.     int i79[] = {0, 1, 0, 1, 1, 0};
    180. 

  180.     int i80[] = {0, 1, 0, 1, 1, 1};
    181. 

  181.     int i81[] = {0, 1, 1, 0, 0, 0};
    182. 

  182.     int i82[] = {0, 1, 1, 0, 0, 1};
    183. 

  183.     int i83[] = {0, 1, 1, 0, 1, 0};
    184. 

  184.     int i84[] = {0, 1, 1, 0, 1, 1};
    185. 

  185.     int i85[] = {0, 1, 1, 1, 0, 0};
    186. 

  186.     int i86[] = {0, 1, 1, 1, 0, 1};
    187. 

  187.     int i87[] = {0, 1, 1, 1, 1, 0};
    188. 

  188.     int i88[] = {0, 1, 1, 1, 1, 1};
    189. 

  189.     int i89[] = {1, 0, 0, 0, 0, 0};
    190. 

  190.     int i90[] = {1, 0, 0, 0, 0, 1};
    191. 

  191.     int i91[] = {1, 0, 0, 0, 1, 0};
    192. 

  192.     int i92[] = {1, 0, 0, 0, 1, 1};
    193. 

  193.     int i93[] = {1, 0, 0, 1, 0, 0};
    194. 

  194.     int i94[] = {1, 0, 0, 1, 0, 1};
    195. 

  195.     int i95[] = {1, 0, 0, 1, 1, 0};
    196. 

  196.     int i96[] = {1, 0, 0, 1, 1, 1};
    197. 

  197.     int i97[] = {1, 0, 1, 0, 0, 0};
    198. 

  198.     int i98[] = {1, 0, 1, 0, 0, 1};
    199. 

  199.     int i99[] = {1, 0, 1, 0, 1, 0};
    200. 

  200.     int i100[] = {1, 0, 1, 0, 1, 1};
    201. 

  201.     int i101[] = {1, 0, 1, 1, 0, 0};
    202. 

  202.     int i102[] = {1, 0, 1, 1, 0, 1};
    203. 

  203.     int i103[] = {1, 0, 1, 1, 1, 0};
    204. 

  204.     int i104[] = {1, 0, 1, 1, 1, 1};
    205. 

  205.     int i105[] = {1, 1, 0, 0, 0, 0};
    206. 

  206.     int i106[] = {1, 1, 0, 0, 0, 1};
    207. 

  207.     int i107[] = {1, 1, 0, 0, 1, 0};
    208. 

  208.     int i108[] = {1, 1, 0, 0, 1, 1};
    209. 

  209.     int i109[] = {1, 1, 0, 1, 0, 0};
    210. 

  210.     int i110[] = {1, 1, 0, 1, 0, 1};
    211. 

  211.     int i111[] = {1, 1, 0, 1, 1, 0};
    212. 

  212.     int i112[] = {1, 1, 0, 1, 1, 1};
    213. 

  213.     int i113[] = {1, 1, 1, 0, 0, 0};
    214. 

  214.     int i114[] = {1, 1, 1, 0, 0, 1};
    215. 

  215.     int i115[] = {1, 1, 1, 0, 1, 0};
    216. 

  216.     int i116[] = {1, 1, 1, 0, 1, 1};
    217. 

  217.     int i117[] = {1, 1, 1, 1, 0, 0};
    218. 

  218.     int i118[] = {1, 1, 1, 1, 0, 1};
    219. 

  219.     int i119[] = {1, 1, 1, 1, 1, 0};
    220. 

  220.     is_heap(i57, i57+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i57, i57+6) == i57+6)); });
    221. 

  221.     is_heap(i58, i58+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i58, i58+6) == i58+6)); });
    222. 

  222.     is_heap(i59, i59+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i59, i59+6) == i59+6)); });
    223. 

  223.     is_heap(i60, i60+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i60, i60+6) == i60+6)); });
    224. 

  224.     is_heap(i61, i61+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i61, i61+6) == i61+6)); });
    225. 

  225.     is_heap(i62, i62+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i62, i62+6) == i62+6)); });
    226. 

  226.     is_heap(i63, i63+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i63, i63+6) == i63+6)); });
    227. 

  227.     is_heap(i64, i64+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i64, i64+6) == i64+6)); });
    228. 

  228.     is_heap(i65, i65+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i65, i65+6) == i65+6)); });
    229. 

  229.     is_heap(i66, i66+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i66, i66+6) == i66+6)); });
    230. 

  230.     is_heap(i67, i67+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i67, i67+6) == i67+6)); });
    231. 

  231.     is_heap(i68, i68+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i68, i68+6) == i68+6)); });
    232. 

  232.     is_heap(i69, i69+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i69, i69+6) == i69+6)); });
    233. 

  233.     is_heap(i70, i70+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i70, i70+6) == i70+6)); });
    234. 

  234.     is_heap(i71, i71+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i71, i71+6) == i71+6)); });
    235. 

  235.     is_heap(i72, i72+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i72, i72+6) == i72+6)); });
    236. 

  236.     is_heap(i73, i73+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i73, i73+6) == i73+6)); });
    237. 

  237.     is_heap(i74, i74+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i74, i74+6) == i74+6)); });
    238. 

  238.     is_heap(i75, i75+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i75, i75+6) == i75+6)); });
    239. 

  239.     is_heap(i76, i76+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i76, i76+6) == i76+6)); });
    240. 

  240.     is_heap(i77, i77+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i77, i77+6) == i77+6)); });
    241. 

  241.     is_heap(i78, i78+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i78, i78+6) == i78+6)); });
    242. 

  242.     is_heap(i79, i79+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i79, i79+6) == i79+6)); });
    243. 

  243.     is_heap(i80, i80+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i80, i80+6) == i80+6)); });
    244. 

  244.     is_heap(i81, i81+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i81, i81+6) == i81+6)); });
    245. 

  245.     is_heap(i82, i82+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i82, i82+6) == i82+6)); });
    246. 

  246.     is_heap(i83, i83+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i83, i83+6) == i83+6)); });
    247. 

  247.     is_heap(i84, i84+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i84, i84+6) == i84+6)); });
    248. 

  248.     is_heap(i85, i85+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i85, i85+6) == i85+6)); });
    249. 

  249.     is_heap(i86, i86+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i86, i86+6) == i86+6)); });
    250. 

  250.     is_heap(i87, i87+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i87, i87+6) == i87+6)); });
    251. 

  251.     is_heap(i88, i88+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i88, i88+6) == i88+6)); });
    252. 

  252.     is_heap(i89, i89+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i89, i89+6) == i89+6)); });
    253. 

  253.     is_heap(i90, i90+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i90, i90+6) == i90+6)); });
    254. 

  254.     is_heap(i91, i91+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i91, i91+6) == i91+6)); });
    255. 

  255.     is_heap(i92, i92+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i92, i92+6) == i92+6)); });
    256. 

  256.     is_heap(i93, i93+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i93, i93+6) == i93+6)); });
    257. 

  257.     is_heap(i94, i94+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i94, i94+6) == i94+6)); });
    258. 

  258.     is_heap(i95, i95+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i95, i95+6) == i95+6)); });
    259. 

  259.     is_heap(i96, i96+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i96, i96+6) == i96+6)); });
    260. 

  260.     is_heap(i97, i97+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i97, i97+6) == i97+6)); });
    261. 

  261.     is_heap(i98, i98+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i98, i98+6) == i98+6)); });
    262. 

  262.     is_heap(i99, i99+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i99, i99+6) == i99+6)); });
    263. 

  263.     is_heap(i100, i100+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i100, i100+6) == i100+6)); });
    264. 

  264.     is_heap(i101, i101+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i101, i101+6) == i101+6)); });
    265. 

  265.     is_heap(i102, i102+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i102, i102+6) == i102+6)); });
    266. 

  266.     is_heap(i103, i103+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i103, i103+6) == i103+6)); });
    267. 

  267.     is_heap(i104, i104+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i104, i104+6) == i104+6)); });
    268. 

  268.     is_heap(i105, i105+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i105, i105+6) == i105+6)); });
    269. 

  269.     is_heap(i106, i106+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i106, i106+6) == i106+6)); });
    270. 

  270.     is_heap(i107, i107+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i107, i107+6) == i107+6)); });
    271. 

  271.     is_heap(i108, i108+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i108, i108+6) == i108+6)); });
    272. 

  272.     is_heap(i109, i109+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i109, i109+6) == i109+6)); });
    273. 

  273.     is_heap(i110, i110+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i110, i110+6) == i110+6)); });
    274. 

  274.     is_heap(i111, i111+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i111, i111+6) == i111+6)); });
    275. 

  275.     is_heap(i112, i112+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i112, i112+6) == i112+6)); });
    276. 

  276.     is_heap(i113, i113+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i113, i113+6) == i113+6)); });
    277. 

  277.     is_heap(i114, i114+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i114, i114+6) == i114+6)); });
    278. 

  278.     is_heap(i115, i115+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i115, i115+6) == i115+6)); });
    279. 

  279.     is_heap(i116, i116+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i116, i116+6) == i116+6)); });
    280. 

  280.     is_heap(i117, i117+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i117, i117+6) == i117+6)); });
    281. 

  281.     is_heap(i118, i118+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i118, i118+6) == i118+6)); });
    282. 

  282.     is_heap(i119, i119+6).check([&](bool r){ CHECK(r == (std::is_heap_until(i119, i119+6) == i119+6)); });
    283. 

  283. #endif
    284. 

  284. #ifdef IS_HEAP_2
    285. 

  285.     int i120[] = {0, 0, 0, 0, 0, 0, 0};
    286. 

  286.     int i121[] = {0, 0, 0, 0, 0, 0, 1};
    287. 

  287.     int i122[] = {0, 0, 0, 0, 0, 1, 0};
    288. 

  288.     int i123[] = {0, 0, 0, 0, 0, 1, 1};
    289. 

  289.     int i124[] = {0, 0, 0, 0, 1, 0, 0};
    290. 

  290.     int i125[] = {0, 0, 0, 0, 1, 0, 1};
    291. 

  291.     int i126[] = {0, 0, 0, 0, 1, 1, 0};
    292. 

  292.     int i127[] = {0, 0, 0, 0, 1, 1, 1};
    293. 

  293.     int i128[] = {0, 0, 0, 1, 0, 0, 0};
    294. 

  294.     int i129[] = {0, 0, 0, 1, 0, 0, 1};
    295. 

  295.     int i130[] = {0, 0, 0, 1, 0, 1, 0};
    296. 

  296.     int i131[] = {0, 0, 0, 1, 0, 1, 1};
    297. 

  297.     int i132[] = {0, 0, 0, 1, 1, 0, 0};
    298. 

  298.     int i133[] = {0, 0, 0, 1, 1, 0, 1};
    299. 

  299.     int i134[] = {0, 0, 0, 1, 1, 1, 0};
    300. 

  300.     int i135[] = {0, 0, 0, 1, 1, 1, 1};
    301. 

  301.     int i136[] = {0, 0, 1, 0, 0, 0, 0};
    302. 

  302.     int i137[] = {0, 0, 1, 0, 0, 0, 1};
    303. 

  303.     int i138[] = {0, 0, 1, 0, 0, 1, 0};
    304. 

  304.     int i139[] = {0, 0, 1, 0, 0, 1, 1};
    305. 

  305.     int i140[] = {0, 0, 1, 0, 1, 0, 0};
    306. 

  306.     int i141[] = {0, 0, 1, 0, 1, 0, 1};
    307. 

  307.     int i142[] = {0, 0, 1, 0, 1, 1, 0};
    308. 

  308.     int i143[] = {0, 0, 1, 0, 1, 1, 1};
    309. 

  309.     int i144[] = {0, 0, 1, 1, 0, 0, 0};
    310. 

  310.     int i145[] = {0, 0, 1, 1, 0, 0, 1};
    311. 

  311.     int i146[] = {0, 0, 1, 1, 0, 1, 0};
    312. 

  312.     int i147[] = {0, 0, 1, 1, 0, 1, 1};
    313. 

  313.     int i148[] = {0, 0, 1, 1, 1, 0, 0};
    314. 

  314.     int i149[] = {0, 0, 1, 1, 1, 0, 1};
    315. 

  315.     int i150[] = {0, 0, 1, 1, 1, 1, 0};
    316. 

  316.     int i151[] = {0, 0, 1, 1, 1, 1, 1};
    317. 

  317.     int i152[] = {0, 1, 0, 0, 0, 0, 0};
    318. 

  318.     int i153[] = {0, 1, 0, 0, 0, 0, 1};
    319. 

  319.     int i154[] = {0, 1, 0, 0, 0, 1, 0};
    320. 

  320.     int i155[] = {0, 1, 0, 0, 0, 1, 1};
    321. 

  321.     int i156[] = {0, 1, 0, 0, 1, 0, 0};
    322. 

  322.     int i157[] = {0, 1, 0, 0, 1, 0, 1};
    323. 

  323.     int i158[] = {0, 1, 0, 0, 1, 1, 0};
    324. 

  324.     int i159[] = {0, 1, 0, 0, 1, 1, 1};
    325. 

  325.     int i160[] = {0, 1, 0, 1, 0, 0, 0};
    326. 

  326.     int i161[] = {0, 1, 0, 1, 0, 0, 1};
    327. 

  327.     int i162[] = {0, 1, 0, 1, 0, 1, 0};
    328. 

  328.     int i163[] = {0, 1, 0, 1, 0, 1, 1};
    329. 

  329.     int i164[] = {0, 1, 0, 1, 1, 0, 0};
    330. 

  330.     int i165[] = {0, 1, 0, 1, 1, 0, 1};
    331. 

  331.     int i166[] = {0, 1, 0, 1, 1, 1, 0};
    332. 

  332.     int i167[] = {0, 1, 0, 1, 1, 1, 1};
    333. 

  333.     int i168[] = {0, 1, 1, 0, 0, 0, 0};
    334. 

  334.     int i169[] = {0, 1, 1, 0, 0, 0, 1};
    335. 

  335.     int i170[] = {0, 1, 1, 0, 0, 1, 0};
    336. 

  336.     int i171[] = {0, 1, 1, 0, 0, 1, 1};
    337. 

  337.     int i172[] = {0, 1, 1, 0, 1, 0, 0};
    338. 

  338.     int i173[] = {0, 1, 1, 0, 1, 0, 1};
    339. 

  339.     int i174[] = {0, 1, 1, 0, 1, 1, 0};
    340. 

  340.     int i175[] = {0, 1, 1, 0, 1, 1, 1};
    341. 

  341.     int i176[] = {0, 1, 1, 1, 0, 0, 0};
    342. 

  342.     int i177[] = {0, 1, 1, 1, 0, 0, 1};
    343. 

  343.     int i178[] = {0, 1, 1, 1, 0, 1, 0};
    344. 

  344.     int i179[] = {0, 1, 1, 1, 0, 1, 1};
    345. 

  345.     int i180[] = {0, 1, 1, 1, 1, 0, 0};
    346. 

  346.     int i181[] = {0, 1, 1, 1, 1, 0, 1};
    347. 

  347.     int i182[] = {0, 1, 1, 1, 1, 1, 0};
    348. 

  348.     int i183[] = {0, 1, 1, 1, 1, 1, 1};
    349. 

  349.     int i184[] = {1, 0, 0, 0, 0, 0, 0};
    350. 

  350.     int i185[] = {1, 0, 0, 0, 0, 0, 1};
    351. 

  351.     int i186[] = {1, 0, 0, 0, 0, 1, 0};
    352. 

  352.     int i187[] = {1, 0, 0, 0, 0, 1, 1};
    353. 

  353.     int i188[] = {1, 0, 0, 0, 1, 0, 0};
    354. 

  354.     int i189[] = {1, 0, 0, 0, 1, 0, 1};
    355. 

  355.     int i190[] = {1, 0, 0, 0, 1, 1, 0};
    356. 

  356.     int i191[] = {1, 0, 0, 0, 1, 1, 1};
    357. 

  357.     int i192[] = {1, 0, 0, 1, 0, 0, 0};
    358. 

  358.     int i193[] = {1, 0, 0, 1, 0, 0, 1};
    359. 

  359.     int i194[] = {1, 0, 0, 1, 0, 1, 0};
    360. 

  360.     int i195[] = {1, 0, 0, 1, 0, 1, 1};
    361. 

  361.     int i196[] = {1, 0, 0, 1, 1, 0, 0};
    362. 

  362.     int i197[] = {1, 0, 0, 1, 1, 0, 1};
    363. 

  363.     int i198[] = {1, 0, 0, 1, 1, 1, 0};
    364. 

  364.     int i199[] = {1, 0, 0, 1, 1, 1, 1};
    365. 

  365.     int i200[] = {1, 0, 1, 0, 0, 0, 0};
    366. 

  366.     int i201[] = {1, 0, 1, 0, 0, 0, 1};
    367. 

  367.     int i202[] = {1, 0, 1, 0, 0, 1, 0};
    368. 

  368.     int i203[] = {1, 0, 1, 0, 0, 1, 1};
    369. 

  369.     int i204[] = {1, 0, 1, 0, 1, 0, 0};
    370. 

  370.     int i205[] = {1, 0, 1, 0, 1, 0, 1};
    371. 

  371.     int i206[] = {1, 0, 1, 0, 1, 1, 0};
    372. 

  372.     int i207[] = {1, 0, 1, 0, 1, 1, 1};
    373. 

  373.     int i208[] = {1, 0, 1, 1, 0, 0, 0};
    374. 

  374.     int i209[] = {1, 0, 1, 1, 0, 0, 1};
    375. 

  375.     int i210[] = {1, 0, 1, 1, 0, 1, 0};
    376. 

  376.     int i211[] = {1, 0, 1, 1, 0, 1, 1};
    377. 

  377.     int i212[] = {1, 0, 1, 1, 1, 0, 0};
    378. 

  378.     int i213[] = {1, 0, 1, 1, 1, 0, 1};
    379. 

  379.     int i214[] = {1, 0, 1, 1, 1, 1, 0};
    380. 

  380.     int i215[] = {1, 0, 1, 1, 1, 1, 1};
    381. 

  381.     int i216[] = {1, 1, 0, 0, 0, 0, 0};
    382. 

  382.     int i217[] = {1, 1, 0, 0, 0, 0, 1};
    383. 

  383.     int i218[] = {1, 1, 0, 0, 0, 1, 0};
    384. 

  384.     int i219[] = {1, 1, 0, 0, 0, 1, 1};
    385. 

  385.     int i220[] = {1, 1, 0, 0, 1, 0, 0};
    386. 

  386.     int i221[] = {1, 1, 0, 0, 1, 0, 1};
    387. 

  387.     int i222[] = {1, 1, 0, 0, 1, 1, 0};
    388. 

  388.     int i223[] = {1, 1, 0, 0, 1, 1, 1};
    389. 

  389.     int i224[] = {1, 1, 0, 1, 0, 0, 0};
    390. 

  390.     int i225[] = {1, 1, 0, 1, 0, 0, 1};
    391. 

  391.     int i226[] = {1, 1, 0, 1, 0, 1, 0};
    392. 

  392.     int i227[] = {1, 1, 0, 1, 0, 1, 1};
    393. 

  393.     int i228[] = {1, 1, 0, 1, 1, 0, 0};
    394. 

  394.     int i229[] = {1, 1, 0, 1, 1, 0, 1};
    395. 

  395.     int i230[] = {1, 1, 0, 1, 1, 1, 0};
    396. 

  396.     int i231[] = {1, 1, 0, 1, 1, 1, 1};
    397. 

  397.     int i232[] = {1, 1, 1, 0, 0, 0, 0};
    398. 

  398.     int i233[] = {1, 1, 1, 0, 0, 0, 1};
    399. 

  399.     int i234[] = {1, 1, 1, 0, 0, 1, 0};
    400. 

  400.     int i235[] = {1, 1, 1, 0, 0, 1, 1};
    401. 

  401.     int i236[] = {1, 1, 1, 0, 1, 0, 0};
    402. 

  402.     int i237[] = {1, 1, 1, 0, 1, 0, 1};
    403. 

  403.     int i238[] = {1, 1, 1, 0, 1, 1, 0};
    404. 

  404.     int i239[] = {1, 1, 1, 0, 1, 1, 1};
    405. 

  405.     int i240[] = {1, 1, 1, 1, 0, 0, 0};
    406. 

  406.     int i241[] = {1, 1, 1, 1, 0, 0, 1};
    407. 

  407.     int i242[] = {1, 1, 1, 1, 0, 1, 0};
    408. 

  408.     int i243[] = {1, 1, 1, 1, 0, 1, 1};
    409. 

  409.     int i244[] = {1, 1, 1, 1, 1, 0, 0};
    410. 

  410.     int i245[] = {1, 1, 1, 1, 1, 0, 1};
    411. 

  411.     int i246[] = {1, 1, 1, 1, 1, 1, 0};
    412. 

  412.     is_heap(i120, i120+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i120, i120+7) == i120+7)); });
    413. 

  413.     is_heap(i121, i121+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i121, i121+7) == i121+7)); });
    414. 

  414.     is_heap(i122, i122+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i122, i122+7) == i122+7)); });
    415. 

  415.     is_heap(i123, i123+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i123, i123+7) == i123+7)); });
    416. 

  416.     is_heap(i124, i124+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i124, i124+7) == i124+7)); });
    417. 

  417.     is_heap(i125, i125+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i125, i125+7) == i125+7)); });
    418. 

  418.     is_heap(i126, i126+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i126, i126+7) == i126+7)); });
    419. 

  419.     is_heap(i127, i127+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i127, i127+7) == i127+7)); });
    420. 

  420.     is_heap(i128, i128+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i128, i128+7) == i128+7)); });
    421. 

  421.     is_heap(i129, i129+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i129, i129+7) == i129+7)); });
    422. 

  422.     is_heap(i130, i130+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i130, i130+7) == i130+7)); });
    423. 

  423.     is_heap(i131, i131+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i131, i131+7) == i131+7)); });
    424. 

  424.     is_heap(i132, i132+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i132, i132+7) == i132+7)); });
    425. 

  425.     is_heap(i133, i133+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i133, i133+7) == i133+7)); });
    426. 

  426.     is_heap(i134, i134+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i134, i134+7) == i134+7)); });
    427. 

  427.     is_heap(i135, i135+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i135, i135+7) == i135+7)); });
    428. 

  428.     is_heap(i136, i136+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i136, i136+7) == i136+7)); });
    429. 

  429.     is_heap(i137, i137+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i137, i137+7) == i137+7)); });
    430. 

  430.     is_heap(i138, i138+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i138, i138+7) == i138+7)); });
    431. 

  431.     is_heap(i139, i139+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i139, i139+7) == i139+7)); });
    432. 

  432.     is_heap(i140, i140+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i140, i140+7) == i140+7)); });
    433. 

  433.     is_heap(i141, i141+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i141, i141+7) == i141+7)); });
    434. 

  434.     is_heap(i142, i142+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i142, i142+7) == i142+7)); });
    435. 

  435.     is_heap(i143, i143+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i143, i143+7) == i143+7)); });
    436. 

  436.     is_heap(i144, i144+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i144, i144+7) == i144+7)); });
    437. 

  437.     is_heap(i145, i145+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i145, i145+7) == i145+7)); });
    438. 

  438.     is_heap(i146, i146+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i146, i146+7) == i146+7)); });
    439. 

  439.     is_heap(i147, i147+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i147, i147+7) == i147+7)); });
    440. 

  440.     is_heap(i148, i148+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i148, i148+7) == i148+7)); });
    441. 

  441.     is_heap(i149, i149+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i149, i149+7) == i149+7)); });
    442. 

  442.     is_heap(i150, i150+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i150, i150+7) == i150+7)); });
    443. 

  443.     is_heap(i151, i151+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i151, i151+7) == i151+7)); });
    444. 

  444.     is_heap(i152, i152+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i152, i152+7) == i152+7)); });
    445. 

  445.     is_heap(i153, i153+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i153, i153+7) == i153+7)); });
    446. 

  446.     is_heap(i154, i154+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i154, i154+7) == i154+7)); });
    447. 

  447.     is_heap(i155, i155+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i155, i155+7) == i155+7)); });
    448. 

  448.     is_heap(i156, i156+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i156, i156+7) == i156+7)); });
    449. 

  449.     is_heap(i157, i157+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i157, i157+7) == i157+7)); });
    450. 

  450.     is_heap(i158, i158+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i158, i158+7) == i158+7)); });
    451. 

  451.     is_heap(i159, i159+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i159, i159+7) == i159+7)); });
    452. 

  452.     is_heap(i160, i160+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i160, i160+7) == i160+7)); });
    453. 

  453.     is_heap(i161, i161+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i161, i161+7) == i161+7)); });
    454. 

  454.     is_heap(i162, i162+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i162, i162+7) == i162+7)); });
    455. 

  455.     is_heap(i163, i163+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i163, i163+7) == i163+7)); });
    456. 

  456.     is_heap(i164, i164+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i164, i164+7) == i164+7)); });
    457. 

  457.     is_heap(i165, i165+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i165, i165+7) == i165+7)); });
    458. 

  458.     is_heap(i166, i166+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i166, i166+7) == i166+7)); });
    459. 

  459.     is_heap(i167, i167+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i167, i167+7) == i167+7)); });
    460. 

  460.     is_heap(i168, i168+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i168, i168+7) == i168+7)); });
    461. 

  461.     is_heap(i169, i169+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i169, i169+7) == i169+7)); });
    462. 

  462.     is_heap(i170, i170+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i170, i170+7) == i170+7)); });
    463. 

  463.     is_heap(i171, i171+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i171, i171+7) == i171+7)); });
    464. 

  464.     is_heap(i172, i172+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i172, i172+7) == i172+7)); });
    465. 

  465.     is_heap(i173, i173+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i173, i173+7) == i173+7)); });
    466. 

  466.     is_heap(i174, i174+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i174, i174+7) == i174+7)); });
    467. 

  467.     is_heap(i175, i175+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i175, i175+7) == i175+7)); });
    468. 

  468.     is_heap(i176, i176+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i176, i176+7) == i176+7)); });
    469. 

  469.     is_heap(i177, i177+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i177, i177+7) == i177+7)); });
    470. 

  470.     is_heap(i178, i178+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i178, i178+7) == i178+7)); });
    471. 

  471.     is_heap(i179, i179+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i179, i179+7) == i179+7)); });
    472. 

  472.     is_heap(i180, i180+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i180, i180+7) == i180+7)); });
    473. 

  473.     is_heap(i181, i181+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i181, i181+7) == i181+7)); });
    474. 

  474.     is_heap(i182, i182+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i182, i182+7) == i182+7)); });
    475. 

  475.     is_heap(i183, i183+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i183, i183+7) == i183+7)); });
    476. 

  476.     is_heap(i184, i184+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i184, i184+7) == i184+7)); });
    477. 

  477.     is_heap(i185, i185+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i185, i185+7) == i185+7)); });
    478. 

  478.     is_heap(i186, i186+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i186, i186+7) == i186+7)); });
    479. 

  479.     is_heap(i187, i187+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i187, i187+7) == i187+7)); });
    480. 

  480.     is_heap(i188, i188+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i188, i188+7) == i188+7)); });
    481. 

  481.     is_heap(i189, i189+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i189, i189+7) == i189+7)); });
    482. 

  482.     is_heap(i190, i190+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i190, i190+7) == i190+7)); });
    483. 

  483.     is_heap(i191, i191+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i191, i191+7) == i191+7)); });
    484. 

  484.     is_heap(i192, i192+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i192, i192+7) == i192+7)); });
    485. 

  485.     is_heap(i193, i193+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i193, i193+7) == i193+7)); });
    486. 

  486.     is_heap(i194, i194+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i194, i194+7) == i194+7)); });
    487. 

  487.     is_heap(i195, i195+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i195, i195+7) == i195+7)); });
    488. 

  488.     is_heap(i196, i196+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i196, i196+7) == i196+7)); });
    489. 

  489.     is_heap(i197, i197+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i197, i197+7) == i197+7)); });
    490. 

  490.     is_heap(i198, i198+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i198, i198+7) == i198+7)); });
    491. 

  491.     is_heap(i199, i199+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i199, i199+7) == i199+7)); });
    492. 

  492.     is_heap(i200, i200+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i200, i200+7) == i200+7)); });
    493. 

  493.     is_heap(i201, i201+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i201, i201+7) == i201+7)); });
    494. 

  494.     is_heap(i202, i202+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i202, i202+7) == i202+7)); });
    495. 

  495.     is_heap(i203, i203+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i203, i203+7) == i203+7)); });
    496. 

  496.     is_heap(i204, i204+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i204, i204+7) == i204+7)); });
    497. 

  497.     is_heap(i205, i205+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i205, i205+7) == i205+7)); });
    498. 

  498.     is_heap(i206, i206+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i206, i206+7) == i206+7)); });
    499. 

  499.     is_heap(i207, i207+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i207, i207+7) == i207+7)); });
    500. 

  500.     is_heap(i208, i208+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i208, i208+7) == i208+7)); });
    501. 

  501.     is_heap(i209, i209+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i209, i209+7) == i209+7)); });
    502. 

  502.     is_heap(i210, i210+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i210, i210+7) == i210+7)); });
    503. 

  503.     is_heap(i211, i211+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i211, i211+7) == i211+7)); });
    504. 

  504.     is_heap(i212, i212+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i212, i212+7) == i212+7)); });
    505. 

  505.     is_heap(i213, i213+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i213, i213+7) == i213+7)); });
    506. 

  506.     is_heap(i214, i214+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i214, i214+7) == i214+7)); });
    507. 

  507.     is_heap(i215, i215+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i215, i215+7) == i215+7)); });
    508. 

  508.     is_heap(i216, i216+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i216, i216+7) == i216+7)); });
    509. 

  509.     is_heap(i217, i217+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i217, i217+7) == i217+7)); });
    510. 

  510.     is_heap(i218, i218+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i218, i218+7) == i218+7)); });
    511. 

  511.     is_heap(i219, i219+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i219, i219+7) == i219+7)); });
    512. 

  512.     is_heap(i220, i220+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i220, i220+7) == i220+7)); });
    513. 

  513.     is_heap(i221, i221+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i221, i221+7) == i221+7)); });
    514. 

  514.     is_heap(i222, i222+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i222, i222+7) == i222+7)); });
    515. 

  515.     is_heap(i223, i223+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i223, i223+7) == i223+7)); });
    516. 

  516.     is_heap(i224, i224+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i224, i224+7) == i224+7)); });
    517. 

  517.     is_heap(i225, i225+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i225, i225+7) == i225+7)); });
    518. 

  518.     is_heap(i226, i226+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i226, i226+7) == i226+7)); });
    519. 

  519.     is_heap(i227, i227+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i227, i227+7) == i227+7)); });
    520. 

  520.     is_heap(i228, i228+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i228, i228+7) == i228+7)); });
    521. 

  521.     is_heap(i229, i229+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i229, i229+7) == i229+7)); });
    522. 

  522.     is_heap(i230, i230+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i230, i230+7) == i230+7)); });
    523. 

  523.     is_heap(i231, i231+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i231, i231+7) == i231+7)); });
    524. 

  524.     is_heap(i232, i232+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i232, i232+7) == i232+7)); });
    525. 

  525.     is_heap(i233, i233+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i233, i233+7) == i233+7)); });
    526. 

  526.     is_heap(i234, i234+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i234, i234+7) == i234+7)); });
    527. 

  527.     is_heap(i235, i235+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i235, i235+7) == i235+7)); });
    528. 

  528.     is_heap(i236, i236+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i236, i236+7) == i236+7)); });
    529. 

  529.     is_heap(i237, i237+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i237, i237+7) == i237+7)); });
    530. 

  530.     is_heap(i238, i238+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i238, i238+7) == i238+7)); });
    531. 

  531.     is_heap(i239, i239+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i239, i239+7) == i239+7)); });
    532. 

  532.     is_heap(i240, i240+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i240, i240+7) == i240+7)); });
    533. 

  533.     is_heap(i241, i241+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i241, i241+7) == i241+7)); });
    534. 

  534.     is_heap(i242, i242+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i242, i242+7) == i242+7)); });
    535. 

  535.     is_heap(i243, i243+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i243, i243+7) == i243+7)); });
    536. 

  536.     is_heap(i244, i244+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i244, i244+7) == i244+7)); });
    537. 

  537.     is_heap(i245, i245+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i245, i245+7) == i245+7)); });
    538. 

  538.     is_heap(i246, i246+7).check([&](bool r){ CHECK(r == (std::is_heap_until(i246, i246+7) == i246+7)); });
    539. 

  539. #endif
    540. 

  540. }
    541. 

  541. 

  542. void test_comp()
    543. 

  543. {
    544. 

  544. #if defined(IS_HEAP_3) || defined(IS_HEAP_4)
    545. 

  545.     auto is_heap = make_testable_1(ranges::is_heap);
    546. 

  546. #endif
    547. 

  547. 

  548. #ifdef IS_HEAP_3
    549. 

  549.     int i1[] = {0, 0};
    550. 

  550.     is_heap(i1, i1, std::greater<int>()).check([&](bool r){ CHECK(r); });
    551. 

  551.     is_heap(i1, i1+1, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i1, i1+1, std::greater<int>()) == i1+1)); });
    552. 

  552.     int i2[] = {0, 1};
    553. 

  553.     int i3[] = {1, 0};
    554. 

  554.     is_heap(i1, i1+2, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i1, i1+2, std::greater<int>()) == i1+2)); });
    555. 

  555.     is_heap(i2, i2+2, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i2, i2+2, std::greater<int>()) == i2+2)); });
    556. 

  556.     is_heap(i3, i3+2, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i3, i3+2, std::greater<int>()) == i3+2)); });
    557. 

  557.     int i4[] = {0, 0, 0};
    558. 

  558.     int i5[] = {0, 0, 1};
    559. 

  559.     int i6[] = {0, 1, 0};
    560. 

  560.     int i7[] = {0, 1, 1};
    561. 

  561.     int i8[] = {1, 0, 0};
    562. 

  562.     int i9[] = {1, 0, 1};
    563. 

  563.     int i10[] = {1, 1, 0};
    564. 

  564.     is_heap(i4, i4+3, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i4, i4+3, std::greater<int>()) == i4+3)); });
    565. 

  565.     is_heap(i5, i5+3, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i5, i5+3, std::greater<int>()) == i5+3)); });
    566. 

  566.     is_heap(i6, i6+3, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i6, i6+3, std::greater<int>()) == i6+3)); });
    567. 

  567.     is_heap(i7, i7+3, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i7, i7+3, std::greater<int>()) == i7+3)); });
    568. 

  568.     is_heap(i8, i8+3, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i8, i8+3, std::greater<int>()) == i8+3)); });
    569. 

  569.     is_heap(i9, i9+3, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i9, i9+3, std::greater<int>()) == i9+3)); });
    570. 

  570.     is_heap(i10, i10+3, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i10, i10+3, std::greater<int>()) == i10+3)); });
    571. 

  571.     int i11[] = {0, 0, 0, 0};
    572. 

  572.     int i12[] = {0, 0, 0, 1};
    573. 

  573.     int i13[] = {0, 0, 1, 0};
    574. 

  574.     int i14[] = {0, 0, 1, 1};
    575. 

  575.     int i15[] = {0, 1, 0, 0};
    576. 

  576.     int i16[] = {0, 1, 0, 1};
    577. 

  577.     int i17[] = {0, 1, 1, 0};
    578. 

  578.     int i18[] = {0, 1, 1, 1};
    579. 

  579.     int i19[] = {1, 0, 0, 0};
    580. 

  580.     int i20[] = {1, 0, 0, 1};
    581. 

  581.     int i21[] = {1, 0, 1, 0};
    582. 

  582.     int i22[] = {1, 0, 1, 1};
    583. 

  583.     int i23[] = {1, 1, 0, 0};
    584. 

  584.     int i24[] = {1, 1, 0, 1};
    585. 

  585.     int i25[] = {1, 1, 1, 0};
    586. 

  586.     is_heap(i11, i11+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i11, i11+4, std::greater<int>()) == i11+4)); });
    587. 

  587.     is_heap(i12, i12+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i12, i12+4, std::greater<int>()) == i12+4)); });
    588. 

  588.     is_heap(i13, i13+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i13, i13+4, std::greater<int>()) == i13+4)); });
    589. 

  589.     is_heap(i14, i14+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i14, i14+4, std::greater<int>()) == i14+4)); });
    590. 

  590.     is_heap(i15, i15+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i15, i15+4, std::greater<int>()) == i15+4)); });
    591. 

  591.     is_heap(i16, i16+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i16, i16+4, std::greater<int>()) == i16+4)); });
    592. 

  592.     is_heap(i17, i17+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i17, i17+4, std::greater<int>()) == i17+4)); });
    593. 

  593.     is_heap(i18, i18+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i18, i18+4, std::greater<int>()) == i18+4)); });
    594. 

  594.     is_heap(i19, i19+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i19, i19+4, std::greater<int>()) == i19+4)); });
    595. 

  595.     is_heap(i20, i20+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i20, i20+4, std::greater<int>()) == i20+4)); });
    596. 

  596.     is_heap(i21, i21+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i21, i21+4, std::greater<int>()) == i21+4)); });
    597. 

  597.     is_heap(i22, i22+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i22, i22+4, std::greater<int>()) == i22+4)); });
    598. 

  598.     is_heap(i23, i23+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i23, i23+4, std::greater<int>()) == i23+4)); });
    599. 

  599.     is_heap(i24, i24+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i24, i24+4, std::greater<int>()) == i24+4)); });
    600. 

  600.     is_heap(i25, i25+4, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i25, i25+4, std::greater<int>()) == i25+4)); });
    601. 

  601.     int i26[] = {0, 0, 0, 0, 0};
    602. 

  602.     int i27[] = {0, 0, 0, 0, 1};
    603. 

  603.     int i28[] = {0, 0, 0, 1, 0};
    604. 

  604.     int i29[] = {0, 0, 0, 1, 1};
    605. 

  605.     int i30[] = {0, 0, 1, 0, 0};
    606. 

  606.     int i31[] = {0, 0, 1, 0, 1};
    607. 

  607.     int i32[] = {0, 0, 1, 1, 0};
    608. 

  608.     int i33[] = {0, 0, 1, 1, 1};
    609. 

  609.     int i34[] = {0, 1, 0, 0, 0};
    610. 

  610.     int i35[] = {0, 1, 0, 0, 1};
    611. 

  611.     int i36[] = {0, 1, 0, 1, 0};
    612. 

  612.     int i37[] = {0, 1, 0, 1, 1};
    613. 

  613.     int i38[] = {0, 1, 1, 0, 0};
    614. 

  614.     int i39[] = {0, 1, 1, 0, 1};
    615. 

  615.     int i40[] = {0, 1, 1, 1, 0};
    616. 

  616.     int i41[] = {0, 1, 1, 1, 1};
    617. 

  617.     int i42[] = {1, 0, 0, 0, 0};
    618. 

  618.     int i43[] = {1, 0, 0, 0, 1};
    619. 

  619.     int i44[] = {1, 0, 0, 1, 0};
    620. 

  620.     int i45[] = {1, 0, 0, 1, 1};
    621. 

  621.     int i46[] = {1, 0, 1, 0, 0};
    622. 

  622.     int i47[] = {1, 0, 1, 0, 1};
    623. 

  623.     int i48[] = {1, 0, 1, 1, 0};
    624. 

  624.     int i49[] = {1, 0, 1, 1, 1};
    625. 

  625.     int i50[] = {1, 1, 0, 0, 0};
    626. 

  626.     int i51[] = {1, 1, 0, 0, 1};
    627. 

  627.     int i52[] = {1, 1, 0, 1, 0};
    628. 

  628.     int i53[] = {1, 1, 0, 1, 1};
    629. 

  629.     int i54[] = {1, 1, 1, 0, 0};
    630. 

  630.     int i55[] = {1, 1, 1, 0, 1};
    631. 

  631.     int i56[] = {1, 1, 1, 1, 0};
    632. 

  632.     is_heap(i26, i26+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i26, i26+5, std::greater<int>()) == i26+5)); });
    633. 

  633.     is_heap(i27, i27+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i27, i27+5, std::greater<int>()) == i27+5)); });
    634. 

  634.     is_heap(i28, i28+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i28, i28+5, std::greater<int>()) == i28+5)); });
    635. 

  635.     is_heap(i29, i29+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i29, i29+5, std::greater<int>()) == i29+5)); });
    636. 

  636.     is_heap(i30, i30+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i30, i30+5, std::greater<int>()) == i30+5)); });
    637. 

  637.     is_heap(i31, i31+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i31, i31+5, std::greater<int>()) == i31+5)); });
    638. 

  638.     is_heap(i32, i32+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i32, i32+5, std::greater<int>()) == i32+5)); });
    639. 

  639.     is_heap(i33, i33+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i33, i33+5, std::greater<int>()) == i33+5)); });
    640. 

  640.     is_heap(i34, i34+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i34, i34+5, std::greater<int>()) == i34+5)); });
    641. 

  641.     is_heap(i35, i35+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i35, i35+5, std::greater<int>()) == i35+5)); });
    642. 

  642.     is_heap(i36, i36+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i36, i36+5, std::greater<int>()) == i36+5)); });
    643. 

  643.     is_heap(i37, i37+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i37, i37+5, std::greater<int>()) == i37+5)); });
    644. 

  644.     is_heap(i38, i38+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i38, i38+5, std::greater<int>()) == i38+5)); });
    645. 

  645.     is_heap(i39, i39+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i39, i39+5, std::greater<int>()) == i39+5)); });
    646. 

  646.     is_heap(i40, i40+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i40, i40+5, std::greater<int>()) == i40+5)); });
    647. 

  647.     is_heap(i41, i41+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i41, i41+5, std::greater<int>()) == i41+5)); });
    648. 

  648.     is_heap(i42, i42+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i42, i42+5, std::greater<int>()) == i42+5)); });
    649. 

  649.     is_heap(i43, i43+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i43, i43+5, std::greater<int>()) == i43+5)); });
    650. 

  650.     is_heap(i44, i44+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i44, i44+5, std::greater<int>()) == i44+5)); });
    651. 

  651.     is_heap(i45, i45+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i45, i45+5, std::greater<int>()) == i45+5)); });
    652. 

  652.     is_heap(i46, i46+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i46, i46+5, std::greater<int>()) == i46+5)); });
    653. 

  653.     is_heap(i47, i47+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i47, i47+5, std::greater<int>()) == i47+5)); });
    654. 

  654.     is_heap(i48, i48+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i48, i48+5, std::greater<int>()) == i48+5)); });
    655. 

  655.     is_heap(i49, i49+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i49, i49+5, std::greater<int>()) == i49+5)); });
    656. 

  656.     is_heap(i50, i50+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i50, i50+5, std::greater<int>()) == i50+5)); });
    657. 

  657.     is_heap(i51, i51+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i51, i51+5, std::greater<int>()) == i51+5)); });
    658. 

  658.     is_heap(i52, i52+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i52, i52+5, std::greater<int>()) == i52+5)); });
    659. 

  659.     is_heap(i53, i53+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i53, i53+5, std::greater<int>()) == i53+5)); });
    660. 

  660.     is_heap(i54, i54+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i54, i54+5, std::greater<int>()) == i54+5)); });
    661. 

  661.     is_heap(i55, i55+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i55, i55+5, std::greater<int>()) == i55+5)); });
    662. 

  662.     is_heap(i56, i56+5, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i56, i56+5, std::greater<int>()) == i56+5)); });
    663. 

  663.     int i57[] = {0, 0, 0, 0, 0, 0};
    664. 

  664.     int i58[] = {0, 0, 0, 0, 0, 1};
    665. 

  665.     int i59[] = {0, 0, 0, 0, 1, 0};
    666. 

  666.     int i60[] = {0, 0, 0, 0, 1, 1};
    667. 

  667.     int i61[] = {0, 0, 0, 1, 0, 0};
    668. 

  668.     int i62[] = {0, 0, 0, 1, 0, 1};
    669. 

  669.     int i63[] = {0, 0, 0, 1, 1, 0};
    670. 

  670.     int i64[] = {0, 0, 0, 1, 1, 1};
    671. 

  671.     int i65[] = {0, 0, 1, 0, 0, 0};
    672. 

  672.     int i66[] = {0, 0, 1, 0, 0, 1};
    673. 

  673.     int i67[] = {0, 0, 1, 0, 1, 0};
    674. 

  674.     int i68[] = {0, 0, 1, 0, 1, 1};
    675. 

  675.     int i69[] = {0, 0, 1, 1, 0, 0};
    676. 

  676.     int i70[] = {0, 0, 1, 1, 0, 1};
    677. 

  677.     int i71[] = {0, 0, 1, 1, 1, 0};
    678. 

  678.     int i72[] = {0, 0, 1, 1, 1, 1};
    679. 

  679.     int i73[] = {0, 1, 0, 0, 0, 0};
    680. 

  680.     int i74[] = {0, 1, 0, 0, 0, 1};
    681. 

  681.     int i75[] = {0, 1, 0, 0, 1, 0};
    682. 

  682.     int i76[] = {0, 1, 0, 0, 1, 1};
    683. 

  683.     int i77[] = {0, 1, 0, 1, 0, 0};
    684. 

  684.     int i78[] = {0, 1, 0, 1, 0, 1};
    685. 

  685.     int i79[] = {0, 1, 0, 1, 1, 0};
    686. 

  686.     int i80[] = {0, 1, 0, 1, 1, 1};
    687. 

  687.     int i81[] = {0, 1, 1, 0, 0, 0};
    688. 

  688.     int i82[] = {0, 1, 1, 0, 0, 1};
    689. 

  689.     int i83[] = {0, 1, 1, 0, 1, 0};
    690. 

  690.     int i84[] = {0, 1, 1, 0, 1, 1};
    691. 

  691.     int i85[] = {0, 1, 1, 1, 0, 0};
    692. 

  692.     int i86[] = {0, 1, 1, 1, 0, 1};
    693. 

  693.     int i87[] = {0, 1, 1, 1, 1, 0};
    694. 

  694.     int i88[] = {0, 1, 1, 1, 1, 1};
    695. 

  695.     int i89[] = {1, 0, 0, 0, 0, 0};
    696. 

  696.     int i90[] = {1, 0, 0, 0, 0, 1};
    697. 

  697.     int i91[] = {1, 0, 0, 0, 1, 0};
    698. 

  698.     int i92[] = {1, 0, 0, 0, 1, 1};
    699. 

  699.     int i93[] = {1, 0, 0, 1, 0, 0};
    700. 

  700.     int i94[] = {1, 0, 0, 1, 0, 1};
    701. 

  701.     int i95[] = {1, 0, 0, 1, 1, 0};
    702. 

  702.     int i96[] = {1, 0, 0, 1, 1, 1};
    703. 

  703.     int i97[] = {1, 0, 1, 0, 0, 0};
    704. 

  704.     int i98[] = {1, 0, 1, 0, 0, 1};
    705. 

  705.     int i99[] = {1, 0, 1, 0, 1, 0};
    706. 

  706.     int i100[] = {1, 0, 1, 0, 1, 1};
    707. 

  707.     int i101[] = {1, 0, 1, 1, 0, 0};
    708. 

  708.     int i102[] = {1, 0, 1, 1, 0, 1};
    709. 

  709.     int i103[] = {1, 0, 1, 1, 1, 0};
    710. 

  710.     int i104[] = {1, 0, 1, 1, 1, 1};
    711. 

  711.     int i105[] = {1, 1, 0, 0, 0, 0};
    712. 

  712.     int i106[] = {1, 1, 0, 0, 0, 1};
    713. 

  713.     int i107[] = {1, 1, 0, 0, 1, 0};
    714. 

  714.     int i108[] = {1, 1, 0, 0, 1, 1};
    715. 

  715.     int i109[] = {1, 1, 0, 1, 0, 0};
    716. 

  716.     int i110[] = {1, 1, 0, 1, 0, 1};
    717. 

  717.     int i111[] = {1, 1, 0, 1, 1, 0};
    718. 

  718.     int i112[] = {1, 1, 0, 1, 1, 1};
    719. 

  719.     int i113[] = {1, 1, 1, 0, 0, 0};
    720. 

  720.     int i114[] = {1, 1, 1, 0, 0, 1};
    721. 

  721.     int i115[] = {1, 1, 1, 0, 1, 0};
    722. 

  722.     int i116[] = {1, 1, 1, 0, 1, 1};
    723. 

  723.     int i117[] = {1, 1, 1, 1, 0, 0};
    724. 

  724.     int i118[] = {1, 1, 1, 1, 0, 1};
    725. 

  725.     int i119[] = {1, 1, 1, 1, 1, 0};
    726. 

  726.     is_heap(i57, i57+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i57, i57+6, std::greater<int>()) == i57+6)); });
    727. 

  727.     is_heap(i58, i58+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i58, i58+6, std::greater<int>()) == i58+6)); });
    728. 

  728.     is_heap(i59, i59+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i59, i59+6, std::greater<int>()) == i59+6)); });
    729. 

  729.     is_heap(i60, i60+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i60, i60+6, std::greater<int>()) == i60+6)); });
    730. 

  730.     is_heap(i61, i61+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i61, i61+6, std::greater<int>()) == i61+6)); });
    731. 

  731.     is_heap(i62, i62+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i62, i62+6, std::greater<int>()) == i62+6)); });
    732. 

  732.     is_heap(i63, i63+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i63, i63+6, std::greater<int>()) == i63+6)); });
    733. 

  733.     is_heap(i64, i64+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i64, i64+6, std::greater<int>()) == i64+6)); });
    734. 

  734.     is_heap(i65, i65+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i65, i65+6, std::greater<int>()) == i65+6)); });
    735. 

  735.     is_heap(i66, i66+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i66, i66+6, std::greater<int>()) == i66+6)); });
    736. 

  736.     is_heap(i67, i67+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i67, i67+6, std::greater<int>()) == i67+6)); });
    737. 

  737.     is_heap(i68, i68+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i68, i68+6, std::greater<int>()) == i68+6)); });
    738. 

  738.     is_heap(i69, i69+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i69, i69+6, std::greater<int>()) == i69+6)); });
    739. 

  739.     is_heap(i70, i70+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i70, i70+6, std::greater<int>()) == i70+6)); });
    740. 

  740.     is_heap(i71, i71+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i71, i71+6, std::greater<int>()) == i71+6)); });
    741. 

  741.     is_heap(i72, i72+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i72, i72+6, std::greater<int>()) == i72+6)); });
    742. 

  742.     is_heap(i73, i73+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i73, i73+6, std::greater<int>()) == i73+6)); });
    743. 

  743.     is_heap(i74, i74+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i74, i74+6, std::greater<int>()) == i74+6)); });
    744. 

  744.     is_heap(i75, i75+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i75, i75+6, std::greater<int>()) == i75+6)); });
    745. 

  745.     is_heap(i76, i76+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i76, i76+6, std::greater<int>()) == i76+6)); });
    746. 

  746.     is_heap(i77, i77+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i77, i77+6, std::greater<int>()) == i77+6)); });
    747. 

  747.     is_heap(i78, i78+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i78, i78+6, std::greater<int>()) == i78+6)); });
    748. 

  748.     is_heap(i79, i79+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i79, i79+6, std::greater<int>()) == i79+6)); });
    749. 

  749.     is_heap(i80, i80+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i80, i80+6, std::greater<int>()) == i80+6)); });
    750. 

  750.     is_heap(i81, i81+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i81, i81+6, std::greater<int>()) == i81+6)); });
    751. 

  751.     is_heap(i82, i82+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i82, i82+6, std::greater<int>()) == i82+6)); });
    752. 

  752.     is_heap(i83, i83+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i83, i83+6, std::greater<int>()) == i83+6)); });
    753. 

  753.     is_heap(i84, i84+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i84, i84+6, std::greater<int>()) == i84+6)); });
    754. 

  754.     is_heap(i85, i85+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i85, i85+6, std::greater<int>()) == i85+6)); });
    755. 

  755.     is_heap(i86, i86+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i86, i86+6, std::greater<int>()) == i86+6)); });
    756. 

  756.     is_heap(i87, i87+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i87, i87+6, std::greater<int>()) == i87+6)); });
    757. 

  757.     is_heap(i88, i88+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i88, i88+6, std::greater<int>()) == i88+6)); });
    758. 

  758.     is_heap(i89, i89+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i89, i89+6, std::greater<int>()) == i89+6)); });
    759. 

  759.     is_heap(i90, i90+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i90, i90+6, std::greater<int>()) == i90+6)); });
    760. 

  760.     is_heap(i91, i91+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i91, i91+6, std::greater<int>()) == i91+6)); });
    761. 

  761.     is_heap(i92, i92+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i92, i92+6, std::greater<int>()) == i92+6)); });
    762. 

  762.     is_heap(i93, i93+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i93, i93+6, std::greater<int>()) == i93+6)); });
    763. 

  763.     is_heap(i94, i94+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i94, i94+6, std::greater<int>()) == i94+6)); });
    764. 

  764.     is_heap(i95, i95+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i95, i95+6, std::greater<int>()) == i95+6)); });
    765. 

  765.     is_heap(i96, i96+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i96, i96+6, std::greater<int>()) == i96+6)); });
    766. 

  766.     is_heap(i97, i97+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i97, i97+6, std::greater<int>()) == i97+6)); });
    767. 

  767.     is_heap(i98, i98+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i98, i98+6, std::greater<int>()) == i98+6)); });
    768. 

  768.     is_heap(i99, i99+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i99, i99+6, std::greater<int>()) == i99+6)); });
    769. 

  769.     is_heap(i100, i100+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i100, i100+6, std::greater<int>()) == i100+6)); });
    770. 

  770.     is_heap(i101, i101+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i101, i101+6, std::greater<int>()) == i101+6)); });
    771. 

  771.     is_heap(i102, i102+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i102, i102+6, std::greater<int>()) == i102+6)); });
    772. 

  772.     is_heap(i103, i103+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i103, i103+6, std::greater<int>()) == i103+6)); });
    773. 

  773.     is_heap(i104, i104+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i104, i104+6, std::greater<int>()) == i104+6)); });
    774. 

  774.     is_heap(i105, i105+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i105, i105+6, std::greater<int>()) == i105+6)); });
    775. 

  775.     is_heap(i106, i106+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i106, i106+6, std::greater<int>()) == i106+6)); });
    776. 

  776.     is_heap(i107, i107+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i107, i107+6, std::greater<int>()) == i107+6)); });
    777. 

  777.     is_heap(i108, i108+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i108, i108+6, std::greater<int>()) == i108+6)); });
    778. 

  778.     is_heap(i109, i109+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i109, i109+6, std::greater<int>()) == i109+6)); });
    779. 

  779.     is_heap(i110, i110+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i110, i110+6, std::greater<int>()) == i110+6)); });
    780. 

  780.     is_heap(i111, i111+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i111, i111+6, std::greater<int>()) == i111+6)); });
    781. 

  781.     is_heap(i112, i112+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i112, i112+6, std::greater<int>()) == i112+6)); });
    782. 

  782.     is_heap(i113, i113+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i113, i113+6, std::greater<int>()) == i113+6)); });
    783. 

  783.     is_heap(i114, i114+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i114, i114+6, std::greater<int>()) == i114+6)); });
    784. 

  784.     is_heap(i115, i115+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i115, i115+6, std::greater<int>()) == i115+6)); });
    785. 

  785.     is_heap(i116, i116+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i116, i116+6, std::greater<int>()) == i116+6)); });
    786. 

  786.     is_heap(i117, i117+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i117, i117+6, std::greater<int>()) == i117+6)); });
    787. 

  787.     is_heap(i118, i118+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i118, i118+6, std::greater<int>()) == i118+6)); });
    788. 

  788.     is_heap(i119, i119+6, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i119, i119+6, std::greater<int>()) == i119+6)); });
    789. 

  789. #endif
    790. 

  790. #ifdef IS_HEAP_4
    791. 

  791.     int i120[] = {0, 0, 0, 0, 0, 0, 0};
    792. 

  792.     int i121[] = {0, 0, 0, 0, 0, 0, 1};
    793. 

  793.     int i122[] = {0, 0, 0, 0, 0, 1, 0};
    794. 

  794.     int i123[] = {0, 0, 0, 0, 0, 1, 1};
    795. 

  795.     int i124[] = {0, 0, 0, 0, 1, 0, 0};
    796. 

  796.     int i125[] = {0, 0, 0, 0, 1, 0, 1};
    797. 

  797.     int i126[] = {0, 0, 0, 0, 1, 1, 0};
    798. 

  798.     int i127[] = {0, 0, 0, 0, 1, 1, 1};
    799. 

  799.     int i128[] = {0, 0, 0, 1, 0, 0, 0};
    800. 

  800.     int i129[] = {0, 0, 0, 1, 0, 0, 1};
    801. 

  801.     int i130[] = {0, 0, 0, 1, 0, 1, 0};
    802. 

  802.     int i131[] = {0, 0, 0, 1, 0, 1, 1};
    803. 

  803.     int i132[] = {0, 0, 0, 1, 1, 0, 0};
    804. 

  804.     int i133[] = {0, 0, 0, 1, 1, 0, 1};
    805. 

  805.     int i134[] = {0, 0, 0, 1, 1, 1, 0};
    806. 

  806.     int i135[] = {0, 0, 0, 1, 1, 1, 1};
    807. 

  807.     int i136[] = {0, 0, 1, 0, 0, 0, 0};
    808. 

  808.     int i137[] = {0, 0, 1, 0, 0, 0, 1};
    809. 

  809.     int i138[] = {0, 0, 1, 0, 0, 1, 0};
    810. 

  810.     int i139[] = {0, 0, 1, 0, 0, 1, 1};
    811. 

  811.     int i140[] = {0, 0, 1, 0, 1, 0, 0};
    812. 

  812.     int i141[] = {0, 0, 1, 0, 1, 0, 1};
    813. 

  813.     int i142[] = {0, 0, 1, 0, 1, 1, 0};
    814. 

  814.     int i143[] = {0, 0, 1, 0, 1, 1, 1};
    815. 

  815.     int i144[] = {0, 0, 1, 1, 0, 0, 0};
    816. 

  816.     int i145[] = {0, 0, 1, 1, 0, 0, 1};
    817. 

  817.     int i146[] = {0, 0, 1, 1, 0, 1, 0};
    818. 

  818.     int i147[] = {0, 0, 1, 1, 0, 1, 1};
    819. 

  819.     int i148[] = {0, 0, 1, 1, 1, 0, 0};
    820. 

  820.     int i149[] = {0, 0, 1, 1, 1, 0, 1};
    821. 

  821.     int i150[] = {0, 0, 1, 1, 1, 1, 0};
    822. 

  822.     int i151[] = {0, 0, 1, 1, 1, 1, 1};
    823. 

  823.     int i152[] = {0, 1, 0, 0, 0, 0, 0};
    824. 

  824.     int i153[] = {0, 1, 0, 0, 0, 0, 1};
    825. 

  825.     int i154[] = {0, 1, 0, 0, 0, 1, 0};
    826. 

  826.     int i155[] = {0, 1, 0, 0, 0, 1, 1};
    827. 

  827.     int i156[] = {0, 1, 0, 0, 1, 0, 0};
    828. 

  828.     int i157[] = {0, 1, 0, 0, 1, 0, 1};
    829. 

  829.     int i158[] = {0, 1, 0, 0, 1, 1, 0};
    830. 

  830.     int i159[] = {0, 1, 0, 0, 1, 1, 1};
    831. 

  831.     int i160[] = {0, 1, 0, 1, 0, 0, 0};
    832. 

  832.     int i161[] = {0, 1, 0, 1, 0, 0, 1};
    833. 

  833.     int i162[] = {0, 1, 0, 1, 0, 1, 0};
    834. 

  834.     int i163[] = {0, 1, 0, 1, 0, 1, 1};
    835. 

  835.     int i164[] = {0, 1, 0, 1, 1, 0, 0};
    836. 

  836.     int i165[] = {0, 1, 0, 1, 1, 0, 1};
    837. 

  837.     int i166[] = {0, 1, 0, 1, 1, 1, 0};
    838. 

  838.     int i167[] = {0, 1, 0, 1, 1, 1, 1};
    839. 

  839.     int i168[] = {0, 1, 1, 0, 0, 0, 0};
    840. 

  840.     int i169[] = {0, 1, 1, 0, 0, 0, 1};
    841. 

  841.     int i170[] = {0, 1, 1, 0, 0, 1, 0};
    842. 

  842.     int i171[] = {0, 1, 1, 0, 0, 1, 1};
    843. 

  843.     int i172[] = {0, 1, 1, 0, 1, 0, 0};
    844. 

  844.     int i173[] = {0, 1, 1, 0, 1, 0, 1};
    845. 

  845.     int i174[] = {0, 1, 1, 0, 1, 1, 0};
    846. 

  846.     int i175[] = {0, 1, 1, 0, 1, 1, 1};
    847. 

  847.     int i176[] = {0, 1, 1, 1, 0, 0, 0};
    848. 

  848.     int i177[] = {0, 1, 1, 1, 0, 0, 1};
    849. 

  849.     int i178[] = {0, 1, 1, 1, 0, 1, 0};
    850. 

  850.     int i179[] = {0, 1, 1, 1, 0, 1, 1};
    851. 

  851.     int i180[] = {0, 1, 1, 1, 1, 0, 0};
    852. 

  852.     int i181[] = {0, 1, 1, 1, 1, 0, 1};
    853. 

  853.     int i182[] = {0, 1, 1, 1, 1, 1, 0};
    854. 

  854.     int i183[] = {0, 1, 1, 1, 1, 1, 1};
    855. 

  855.     int i184[] = {1, 0, 0, 0, 0, 0, 0};
    856. 

  856.     int i185[] = {1, 0, 0, 0, 0, 0, 1};
    857. 

  857.     int i186[] = {1, 0, 0, 0, 0, 1, 0};
    858. 

  858.     int i187[] = {1, 0, 0, 0, 0, 1, 1};
    859. 

  859.     int i188[] = {1, 0, 0, 0, 1, 0, 0};
    860. 

  860.     int i189[] = {1, 0, 0, 0, 1, 0, 1};
    861. 

  861.     int i190[] = {1, 0, 0, 0, 1, 1, 0};
    862. 

  862.     int i191[] = {1, 0, 0, 0, 1, 1, 1};
    863. 

  863.     int i192[] = {1, 0, 0, 1, 0, 0, 0};
    864. 

  864.     int i193[] = {1, 0, 0, 1, 0, 0, 1};
    865. 

  865.     int i194[] = {1, 0, 0, 1, 0, 1, 0};
    866. 

  866.     int i195[] = {1, 0, 0, 1, 0, 1, 1};
    867. 

  867.     int i196[] = {1, 0, 0, 1, 1, 0, 0};
    868. 

  868.     int i197[] = {1, 0, 0, 1, 1, 0, 1};
    869. 

  869.     int i198[] = {1, 0, 0, 1, 1, 1, 0};
    870. 

  870.     int i199[] = {1, 0, 0, 1, 1, 1, 1};
    871. 

  871.     int i200[] = {1, 0, 1, 0, 0, 0, 0};
    872. 

  872.     int i201[] = {1, 0, 1, 0, 0, 0, 1};
    873. 

  873.     int i202[] = {1, 0, 1, 0, 0, 1, 0};
    874. 

  874.     int i203[] = {1, 0, 1, 0, 0, 1, 1};
    875. 

  875.     int i204[] = {1, 0, 1, 0, 1, 0, 0};
    876. 

  876.     int i205[] = {1, 0, 1, 0, 1, 0, 1};
    877. 

  877.     int i206[] = {1, 0, 1, 0, 1, 1, 0};
    878. 

  878.     int i207[] = {1, 0, 1, 0, 1, 1, 1};
    879. 

  879.     int i208[] = {1, 0, 1, 1, 0, 0, 0};
    880. 

  880.     int i209[] = {1, 0, 1, 1, 0, 0, 1};
    881. 

  881.     int i210[] = {1, 0, 1, 1, 0, 1, 0};
    882. 

  882.     int i211[] = {1, 0, 1, 1, 0, 1, 1};
    883. 

  883.     int i212[] = {1, 0, 1, 1, 1, 0, 0};
    884. 

  884.     int i213[] = {1, 0, 1, 1, 1, 0, 1};
    885. 

  885.     int i214[] = {1, 0, 1, 1, 1, 1, 0};
    886. 

  886.     int i215[] = {1, 0, 1, 1, 1, 1, 1};
    887. 

  887.     int i216[] = {1, 1, 0, 0, 0, 0, 0};
    888. 

  888.     int i217[] = {1, 1, 0, 0, 0, 0, 1};
    889. 

  889.     int i218[] = {1, 1, 0, 0, 0, 1, 0};
    890. 

  890.     int i219[] = {1, 1, 0, 0, 0, 1, 1};
    891. 

  891.     int i220[] = {1, 1, 0, 0, 1, 0, 0};
    892. 

  892.     int i221[] = {1, 1, 0, 0, 1, 0, 1};
    893. 

  893.     int i222[] = {1, 1, 0, 0, 1, 1, 0};
    894. 

  894.     int i223[] = {1, 1, 0, 0, 1, 1, 1};
    895. 

  895.     int i224[] = {1, 1, 0, 1, 0, 0, 0};
    896. 

  896.     int i225[] = {1, 1, 0, 1, 0, 0, 1};
    897. 

  897.     int i226[] = {1, 1, 0, 1, 0, 1, 0};
    898. 

  898.     int i227[] = {1, 1, 0, 1, 0, 1, 1};
    899. 

  899.     int i228[] = {1, 1, 0, 1, 1, 0, 0};
    900. 

  900.     int i229[] = {1, 1, 0, 1, 1, 0, 1};
    901. 

  901.     int i230[] = {1, 1, 0, 1, 1, 1, 0};
    902. 

  902.     int i231[] = {1, 1, 0, 1, 1, 1, 1};
    903. 

  903.     int i232[] = {1, 1, 1, 0, 0, 0, 0};
    904. 

  904.     int i233[] = {1, 1, 1, 0, 0, 0, 1};
    905. 

  905.     int i234[] = {1, 1, 1, 0, 0, 1, 0};
    906. 

  906.     int i235[] = {1, 1, 1, 0, 0, 1, 1};
    907. 

  907.     int i236[] = {1, 1, 1, 0, 1, 0, 0};
    908. 

  908.     int i237[] = {1, 1, 1, 0, 1, 0, 1};
    909. 

  909.     int i238[] = {1, 1, 1, 0, 1, 1, 0};
    910. 

  910.     int i239[] = {1, 1, 1, 0, 1, 1, 1};
    911. 

  911.     int i240[] = {1, 1, 1, 1, 0, 0, 0};
    912. 

  912.     int i241[] = {1, 1, 1, 1, 0, 0, 1};
    913. 

  913.     int i242[] = {1, 1, 1, 1, 0, 1, 0};
    914. 

  914.     int i243[] = {1, 1, 1, 1, 0, 1, 1};
    915. 

  915.     int i244[] = {1, 1, 1, 1, 1, 0, 0};
    916. 

  916.     int i245[] = {1, 1, 1, 1, 1, 0, 1};
    917. 

  917.     int i246[] = {1, 1, 1, 1, 1, 1, 0};
    918. 

  918.     is_heap(i120, i120+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i120, i120+7, std::greater<int>()) == i120+7)); });
    919. 

  919.     is_heap(i121, i121+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i121, i121+7, std::greater<int>()) == i121+7)); });
    920. 

  920.     is_heap(i122, i122+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i122, i122+7, std::greater<int>()) == i122+7)); });
    921. 

  921.     is_heap(i123, i123+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i123, i123+7, std::greater<int>()) == i123+7)); });
    922. 

  922.     is_heap(i124, i124+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i124, i124+7, std::greater<int>()) == i124+7)); });
    923. 

  923.     is_heap(i125, i125+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i125, i125+7, std::greater<int>()) == i125+7)); });
    924. 

  924.     is_heap(i126, i126+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i126, i126+7, std::greater<int>()) == i126+7)); });
    925. 

  925.     is_heap(i127, i127+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i127, i127+7, std::greater<int>()) == i127+7)); });
    926. 

  926.     is_heap(i128, i128+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i128, i128+7, std::greater<int>()) == i128+7)); });
    927. 

  927.     is_heap(i129, i129+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i129, i129+7, std::greater<int>()) == i129+7)); });
    928. 

  928.     is_heap(i130, i130+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i130, i130+7, std::greater<int>()) == i130+7)); });
    929. 

  929.     is_heap(i131, i131+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i131, i131+7, std::greater<int>()) == i131+7)); });
    930. 

  930.     is_heap(i132, i132+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i132, i132+7, std::greater<int>()) == i132+7)); });
    931. 

  931.     is_heap(i133, i133+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i133, i133+7, std::greater<int>()) == i133+7)); });
    932. 

  932.     is_heap(i134, i134+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i134, i134+7, std::greater<int>()) == i134+7)); });
    933. 

  933.     is_heap(i135, i135+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i135, i135+7, std::greater<int>()) == i135+7)); });
    934. 

  934.     is_heap(i136, i136+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i136, i136+7, std::greater<int>()) == i136+7)); });
    935. 

  935.     is_heap(i137, i137+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i137, i137+7, std::greater<int>()) == i137+7)); });
    936. 

  936.     is_heap(i138, i138+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i138, i138+7, std::greater<int>()) == i138+7)); });
    937. 

  937.     is_heap(i139, i139+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i139, i139+7, std::greater<int>()) == i139+7)); });
    938. 

  938.     is_heap(i140, i140+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i140, i140+7, std::greater<int>()) == i140+7)); });
    939. 

  939.     is_heap(i141, i141+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i141, i141+7, std::greater<int>()) == i141+7)); });
    940. 

  940.     is_heap(i142, i142+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i142, i142+7, std::greater<int>()) == i142+7)); });
    941. 

  941.     is_heap(i143, i143+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i143, i143+7, std::greater<int>()) == i143+7)); });
    942. 

  942.     is_heap(i144, i144+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i144, i144+7, std::greater<int>()) == i144+7)); });
    943. 

  943.     is_heap(i145, i145+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i145, i145+7, std::greater<int>()) == i145+7)); });
    944. 

  944.     is_heap(i146, i146+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i146, i146+7, std::greater<int>()) == i146+7)); });
    945. 

  945.     is_heap(i147, i147+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i147, i147+7, std::greater<int>()) == i147+7)); });
    946. 

  946.     is_heap(i148, i148+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i148, i148+7, std::greater<int>()) == i148+7)); });
    947. 

  947.     is_heap(i149, i149+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i149, i149+7, std::greater<int>()) == i149+7)); });
    948. 

  948.     is_heap(i150, i150+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i150, i150+7, std::greater<int>()) == i150+7)); });
    949. 

  949.     is_heap(i151, i151+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i151, i151+7, std::greater<int>()) == i151+7)); });
    950. 

  950.     is_heap(i152, i152+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i152, i152+7, std::greater<int>()) == i152+7)); });
    951. 

  951.     is_heap(i153, i153+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i153, i153+7, std::greater<int>()) == i153+7)); });
    952. 

  952.     is_heap(i154, i154+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i154, i154+7, std::greater<int>()) == i154+7)); });
    953. 

  953.     is_heap(i155, i155+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i155, i155+7, std::greater<int>()) == i155+7)); });
    954. 

  954.     is_heap(i156, i156+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i156, i156+7, std::greater<int>()) == i156+7)); });
    955. 

  955.     is_heap(i157, i157+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i157, i157+7, std::greater<int>()) == i157+7)); });
    956. 

  956.     is_heap(i158, i158+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i158, i158+7, std::greater<int>()) == i158+7)); });
    957. 

  957.     is_heap(i159, i159+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i159, i159+7, std::greater<int>()) == i159+7)); });
    958. 

  958.     is_heap(i160, i160+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i160, i160+7, std::greater<int>()) == i160+7)); });
    959. 

  959.     is_heap(i161, i161+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i161, i161+7, std::greater<int>()) == i161+7)); });
    960. 

  960.     is_heap(i162, i162+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i162, i162+7, std::greater<int>()) == i162+7)); });
    961. 

  961.     is_heap(i163, i163+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i163, i163+7, std::greater<int>()) == i163+7)); });
    962. 

  962.     is_heap(i164, i164+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i164, i164+7, std::greater<int>()) == i164+7)); });
    963. 

  963.     is_heap(i165, i165+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i165, i165+7, std::greater<int>()) == i165+7)); });
    964. 

  964.     is_heap(i166, i166+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i166, i166+7, std::greater<int>()) == i166+7)); });
    965. 

  965.     is_heap(i167, i167+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i167, i167+7, std::greater<int>()) == i167+7)); });
    966. 

  966.     is_heap(i168, i168+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i168, i168+7, std::greater<int>()) == i168+7)); });
    967. 

  967.     is_heap(i169, i169+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i169, i169+7, std::greater<int>()) == i169+7)); });
    968. 

  968.     is_heap(i170, i170+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i170, i170+7, std::greater<int>()) == i170+7)); });
    969. 

  969.     is_heap(i171, i171+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i171, i171+7, std::greater<int>()) == i171+7)); });
    970. 

  970.     is_heap(i172, i172+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i172, i172+7, std::greater<int>()) == i172+7)); });
    971. 

  971.     is_heap(i173, i173+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i173, i173+7, std::greater<int>()) == i173+7)); });
    972. 

  972.     is_heap(i174, i174+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i174, i174+7, std::greater<int>()) == i174+7)); });
    973. 

  973.     is_heap(i175, i175+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i175, i175+7, std::greater<int>()) == i175+7)); });
    974. 

  974.     is_heap(i176, i176+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i176, i176+7, std::greater<int>()) == i176+7)); });
    975. 

  975.     is_heap(i177, i177+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i177, i177+7, std::greater<int>()) == i177+7)); });
    976. 

  976.     is_heap(i178, i178+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i178, i178+7, std::greater<int>()) == i178+7)); });
    977. 

  977.     is_heap(i179, i179+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i179, i179+7, std::greater<int>()) == i179+7)); });
    978. 

  978.     is_heap(i180, i180+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i180, i180+7, std::greater<int>()) == i180+7)); });
    979. 

  979.     is_heap(i181, i181+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i181, i181+7, std::greater<int>()) == i181+7)); });
    980. 

  980.     is_heap(i182, i182+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i182, i182+7, std::greater<int>()) == i182+7)); });
    981. 

  981.     is_heap(i183, i183+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i183, i183+7, std::greater<int>()) == i183+7)); });
    982. 

  982.     is_heap(i184, i184+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i184, i184+7, std::greater<int>()) == i184+7)); });
    983. 

  983.     is_heap(i185, i185+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i185, i185+7, std::greater<int>()) == i185+7)); });
    984. 

  984.     is_heap(i186, i186+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i186, i186+7, std::greater<int>()) == i186+7)); });
    985. 

  985.     is_heap(i187, i187+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i187, i187+7, std::greater<int>()) == i187+7)); });
    986. 

  986.     is_heap(i188, i188+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i188, i188+7, std::greater<int>()) == i188+7)); });
    987. 

  987.     is_heap(i189, i189+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i189, i189+7, std::greater<int>()) == i189+7)); });
    988. 

  988.     is_heap(i190, i190+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i190, i190+7, std::greater<int>()) == i190+7)); });
    989. 

  989.     is_heap(i191, i191+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i191, i191+7, std::greater<int>()) == i191+7)); });
    990. 

  990.     is_heap(i192, i192+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i192, i192+7, std::greater<int>()) == i192+7)); });
    991. 

  991.     is_heap(i193, i193+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i193, i193+7, std::greater<int>()) == i193+7)); });
    992. 

  992.     is_heap(i194, i194+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i194, i194+7, std::greater<int>()) == i194+7)); });
    993. 

  993.     is_heap(i195, i195+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i195, i195+7, std::greater<int>()) == i195+7)); });
    994. 

  994.     is_heap(i196, i196+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i196, i196+7, std::greater<int>()) == i196+7)); });
    995. 

  995.     is_heap(i197, i197+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i197, i197+7, std::greater<int>()) == i197+7)); });
    996. 

  996.     is_heap(i198, i198+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i198, i198+7, std::greater<int>()) == i198+7)); });
    997. 

  997.     is_heap(i199, i199+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i199, i199+7, std::greater<int>()) == i199+7)); });
    998. 

  998.     is_heap(i200, i200+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i200, i200+7, std::greater<int>()) == i200+7)); });
    999. 

  999.     is_heap(i201, i201+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i201, i201+7, std::greater<int>()) == i201+7)); });
    1000. 

  1000.     is_heap(i202, i202+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i202, i202+7, std::greater<int>()) == i202+7)); });
    1001. 

  1001.     is_heap(i203, i203+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i203, i203+7, std::greater<int>()) == i203+7)); });
    1002. 

  1002.     is_heap(i204, i204+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i204, i204+7, std::greater<int>()) == i204+7)); });
    1003. 

  1003.     is_heap(i205, i205+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i205, i205+7, std::greater<int>()) == i205+7)); });
    1004. 

  1004.     is_heap(i206, i206+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i206, i206+7, std::greater<int>()) == i206+7)); });
    1005. 

  1005.     is_heap(i207, i207+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i207, i207+7, std::greater<int>()) == i207+7)); });
    1006. 

  1006.     is_heap(i208, i208+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i208, i208+7, std::greater<int>()) == i208+7)); });
    1007. 

  1007.     is_heap(i209, i209+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i209, i209+7, std::greater<int>()) == i209+7)); });
    1008. 

  1008.     is_heap(i210, i210+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i210, i210+7, std::greater<int>()) == i210+7)); });
    1009. 

  1009.     is_heap(i211, i211+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i211, i211+7, std::greater<int>()) == i211+7)); });
    1010. 

  1010.     is_heap(i212, i212+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i212, i212+7, std::greater<int>()) == i212+7)); });
    1011. 

  1011.     is_heap(i213, i213+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i213, i213+7, std::greater<int>()) == i213+7)); });
    1012. 

  1012.     is_heap(i214, i214+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i214, i214+7, std::greater<int>()) == i214+7)); });
    1013. 

  1013.     is_heap(i215, i215+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i215, i215+7, std::greater<int>()) == i215+7)); });
    1014. 

  1014.     is_heap(i216, i216+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i216, i216+7, std::greater<int>()) == i216+7)); });
    1015. 

  1015.     is_heap(i217, i217+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i217, i217+7, std::greater<int>()) == i217+7)); });
    1016. 

  1016.     is_heap(i218, i218+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i218, i218+7, std::greater<int>()) == i218+7)); });
    1017. 

  1017.     is_heap(i219, i219+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i219, i219+7, std::greater<int>()) == i219+7)); });
    1018. 

  1018.     is_heap(i220, i220+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i220, i220+7, std::greater<int>()) == i220+7)); });
    1019. 

  1019.     is_heap(i221, i221+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i221, i221+7, std::greater<int>()) == i221+7)); });
    1020. 

  1020.     is_heap(i222, i222+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i222, i222+7, std::greater<int>()) == i222+7)); });
    1021. 

  1021.     is_heap(i223, i223+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i223, i223+7, std::greater<int>()) == i223+7)); });
    1022. 

  1022.     is_heap(i224, i224+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i224, i224+7, std::greater<int>()) == i224+7)); });
    1023. 

  1023.     is_heap(i225, i225+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i225, i225+7, std::greater<int>()) == i225+7)); });
    1024. 

  1024.     is_heap(i226, i226+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i226, i226+7, std::greater<int>()) == i226+7)); });
    1025. 

  1025.     is_heap(i227, i227+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i227, i227+7, std::greater<int>()) == i227+7)); });
    1026. 

  1026.     is_heap(i228, i228+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i228, i228+7, std::greater<int>()) == i228+7)); });
    1027. 

  1027.     is_heap(i229, i229+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i229, i229+7, std::greater<int>()) == i229+7)); });
    1028. 

  1028.     is_heap(i230, i230+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i230, i230+7, std::greater<int>()) == i230+7)); });
    1029. 

  1029.     is_heap(i231, i231+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i231, i231+7, std::greater<int>()) == i231+7)); });
    1030. 

  1030.     is_heap(i232, i232+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i232, i232+7, std::greater<int>()) == i232+7)); });
    1031. 

  1031.     is_heap(i233, i233+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i233, i233+7, std::greater<int>()) == i233+7)); });
    1032. 

  1032.     is_heap(i234, i234+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i234, i234+7, std::greater<int>()) == i234+7)); });
    1033. 

  1033.     is_heap(i235, i235+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i235, i235+7, std::greater<int>()) == i235+7)); });
    1034. 

  1034.     is_heap(i236, i236+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i236, i236+7, std::greater<int>()) == i236+7)); });
    1035. 

  1035.     is_heap(i237, i237+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i237, i237+7, std::greater<int>()) == i237+7)); });
    1036. 

  1036.     is_heap(i238, i238+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i238, i238+7, std::greater<int>()) == i238+7)); });
    1037. 

  1037.     is_heap(i239, i239+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i239, i239+7, std::greater<int>()) == i239+7)); });
    1038. 

  1038.     is_heap(i240, i240+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i240, i240+7, std::greater<int>()) == i240+7)); });
    1039. 

  1039.     is_heap(i241, i241+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i241, i241+7, std::greater<int>()) == i241+7)); });
    1040. 

  1040.     is_heap(i242, i242+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i242, i242+7, std::greater<int>()) == i242+7)); });
    1041. 

  1041.     is_heap(i243, i243+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i243, i243+7, std::greater<int>()) == i243+7)); });
    1042. 

  1042.     is_heap(i244, i244+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i244, i244+7, std::greater<int>()) == i244+7)); });
    1043. 

  1043.     is_heap(i245, i245+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i245, i245+7, std::greater<int>()) == i245+7)); });
    1044. 

  1044.     is_heap(i246, i246+7, std::greater<int>()).check([&](bool r){ CHECK(r == (std::is_heap_until(i246, i246+7, std::greater<int>()) == i246+7)); });
    1045. 

  1045. #endif
    1046. 

  1046. }
    1047. 

  1047. 

  1048. struct S
    1049. 

  1049. {
    1050. 

  1050.     int i;
    1051. 

  1051. };
    1052. 

  1052. 

  1053. int main()
    1054. 

  1054. {
    1055. 

  1055.     test();
    1056. 

  1056.     test_comp();
    1057. 

  1057. 

  1058.     // Test projections:
    1059. 

  1059.     S i183[] = {S{0}, S{1}, S{1}, S{1}, S{1}, S{1}, S{1}};
    1060. 

  1060.     CHECK(ranges::is_heap(i183, i183+7, std::greater<int>(), &S::i));
    1061. 

  1061. 

  1062.     {
    1063. 

  1063.         using IL = std::initializer_list<int>;
    1064. 

  1064.         STATIC_CHECK(ranges::is_heap(IL{0, 1, 1, 1, 1, 1, 1}, ranges::greater{}));
    1065. 

  1065.     }
    1066. 

  1066. 

  1067.     return ::test_result();
    1068. 

  1068. }
    1069.