[ 0:01] compiling /home/xrockai/src/divine/nightly/test/libcxx/algorithms/is_heap.pass.cpp [ 0:01] In file included from /home/xrockai/src/divine/nightly/test/libcxx/algorithms/is_heap.pass.cpp:19: [ 0:01] In file included from /dios/libcxx/include/algorithm:639: [ 0:01] In file included from /dios/libcxx/include/initializer_list:46: [ 0:01] In file included from /dios/libcxx/include/cstddef:44: [ 0:01] In file included from /dios/include/stddef.h:10: [ 0:01] In file included from /dios/include/_PDCLIB/int.h:16: [ 0:01] /dios/include/_PDCLIB/cdefs.h:69:10: warning: Unsupported _ _cplusplus (__cplusplus) (too new) (supported: ISO/IEC 14882:1997, ISO/IEC 14882:2011). [ 0:01] #warning Unsupported _ _cplusplus (__cplusplus) (too new) (supported: ISO/IEC 14882:1997, ISO/IEC 14882:2011). [ 0:01] ^ [ 0:01] 1 warning generated. [ 0:02] compiling /dios/lib/config/seqklee.bc [ 0:02] setting up pass: functionmeta, options = [ 0:03] setting up pass: fuse-ctors, options = [ 0:03] KLEE: output directory is "/var/obj/divine-nightly/semidbg/test/__test_work_dir.19/_klee_out" [ 0:05] KLEE: Using Z3 solver backend [ 0:05] WARNING: this target does not support the llvm.stacksave intrinsic. [ 0:06] warning: Linking two modules of different target triples: klee_div_zero_check.bc' is 'x86_64-unknown-linux-gnu' whereas 'klee.bc' is 'x86_64-unknown-none-elf' [ 0:06] [ 0:06] KLEE: WARNING: undefined reference to function: __dios_tainted_init [ 0:08] KLEE: WARNING: undefined reference to function: klee_free [ 0:08] KLEE: WARNING: undefined reference to function: klee_malloc [ 0:08] i:1 [ 0:09] KLEE: WARNING ONCE: Alignment of memory from call "klee_malloc" is not modelled. Using alignment of 8. [ 0:09] about to __boot:0 [ 0:09] about to run the scheduler:0 [ 0:09] KLEE: WARNING ONCE: calling external: __dios_tainted_init() at /dios/libc/sys/start.cpp:49 5 [ 0:09] KLEE: ERROR: /dios/libc/sys/start.cpp:87: failed external call: __dios_tainted_init [ 0:09] KLEE: NOTE: now ignoring this error at this location [ 0:09] KLEE: ERROR: EXITING ON ERROR: [ 0:09] Error: failed external call: __dios_tainted_init [ 0:09] File: /dios/libc/sys/start.cpp [ 0:09] Line: 87 [ 0:09] assembly.ll line: 49152 [ 0:09] Stack: [ 0:09] #000049152 in __dios_start (l=2, argc=1, argv=94423686025736, envp=94423686127624) at /dios/libc/sys/start.cpp:87 [ 0:09] #100025161 in _ZN6__dios10sched_nullINS_5ClockINS_10NondetKleeINS_4BaseEEEEEE13run_schedulerINS_7ContextEEEvv () at /dios/sys/sched_null.hpp:163 [ 0:09] #200057400 in klee_boot (argc=2, argv=94423655323648) at /dios/arch/klee/boot.c:41 [ 0:09] [ 0:09] [ 0:09] 1 /* TAGS: c++ fin */ [ 0:09] 2 /* CC_OPTS: -std=c++2a */ [ 0:09] 3 /* VERIFY_OPTS: -o nofail:malloc */ [ 0:09] 4 //===----------------------------------------------------------------------===// [ 0:09] 5 // [ 0:09] 6 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. [ 0:09] 7 // See https://llvm.org/LICENSE.txt for license information. [ 0:09] 8 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception [ 0:09] 9 // [ 0:09] 10 //===----------------------------------------------------------------------===// [ 0:09] 11 [ 0:09] 12 // [ 0:09] 13 [ 0:09] 14 // template [ 0:09] 15 // requires LessThanComparable [ 0:09] 16 // constexpr bool // constexpr after C++17 [ 0:09] 17 // is_heap(Iter first, Iter last); [ 0:09] 18 [ 0:09] 19 #include [ 0:09] 20 #include [ 0:09] 21 [ 0:09] 22 #include "test_macros.h" [ 0:09] 23 [ 0:09] 24 #if TEST_STD_VER > 17 [ 0:09] 25 TEST_CONSTEXPR bool test_constexpr() { [ 0:09] 26 int ia[] = {1, 1, 1, 1, 0, 1, 1}; [ 0:09] 27 int ib[] = {0, 0, 1, 0, 0, 0, 0}; [ 0:09] 28 return std::is_heap(std::begin(ia), std::end(ia)) [ 0:09] 29 && !std::is_heap(std::begin(ib), std::end(ib)); [ 0:09] 30 } [ 0:09] 31 #endif [ 0:09] 32 [ 0:09] 33 void test() [ 0:09] 34 { [ 0:09] 35 int i1[] = {0, 0}; [ 0:09] 36 assert(std::is_heap(i1, i1)); [ 0:09] 37 assert(std::is_heap(i1, i1+1) == (std::is_heap_until(i1, i1+1) == i1+1)); [ 0:09] 38 int i2[] = {0, 1}; [ 0:09] 39 int i3[] = {1, 0}; [ 0:09] 40 assert(std::is_heap(i1, i1+2) == (std::is_heap_until(i1, i1+2) == i1+2)); [ 0:09] 41 assert(std::is_heap(i2, i2+2) == (std::is_heap_until(i2, i2+2) == i2+2)); [ 0:09] 42 assert(std::is_heap(i3, i3+2) == (std::is_heap_until(i3, i3+2) == i3+2)); [ 0:09] 43 int i4[] = {0, 0, 0}; [ 0:09] 44 int i5[] = {0, 0, 1}; [ 0:09] 45 int i6[] = {0, 1, 0}; [ 0:09] 46 int i7[] = {0, 1, 1}; [ 0:09] 47 int i8[] = {1, 0, 0}; [ 0:09] 48 int i9[] = {1, 0, 1}; [ 0:09] 49 int i10[] = {1, 1, 0}; [ 0:09] 50 assert(std::is_heap(i4, i4+3) == (std::is_heap_until(i4, i4+3) == i4+3)); [ 0:09] 51 assert(std::is_heap(i5, i5+3) == (std::is_heap_until(i5, i5+3) == i5+3)); [ 0:09] 52 assert(std::is_heap(i6, i6+3) == (std::is_heap_until(i6, i6+3) == i6+3)); [ 0:09] 53 assert(std::is_heap(i7, i7+3) == (std::is_heap_until(i7, i7+3) == i7+3)); [ 0:09] 54 assert(std::is_heap(i8, i8+3) == (std::is_heap_until(i8, i8+3) == i8+3)); [ 0:09] 55 assert(std::is_heap(i9, i9+3) == (std::is_heap_until(i9, i9+3) == i9+3)); [ 0:09] 56 assert(std::is_heap(i10, i10+3) == (std::is_heap_until(i10, i10+3) == i10+3)); [ 0:09] 57 int i11[] = {0, 0, 0, 0}; [ 0:09] 58 int i12[] = {0, 0, 0, 1}; [ 0:09] 59 int i13[] = {0, 0, 1, 0}; [ 0:09] 60 int i14[] = {0, 0, 1, 1}; [ 0:09] 61 int i15[] = {0, 1, 0, 0}; [ 0:09] 62 int i16[] = {0, 1, 0, 1}; [ 0:09] 63 int i17[] = {0, 1, 1, 0}; [ 0:09] 64 int i18[] = {0, 1, 1, 1}; [ 0:09] 65 int i19[] = {1, 0, 0, 0}; [ 0:09] 66 int i20[] = {1, 0, 0, 1}; [ 0:09] 67 int i21[] = {1, 0, 1, 0}; [ 0:09] 68 int i22[] = {1, 0, 1, 1}; [ 0:09] 69 int i23[] = {1, 1, 0, 0}; [ 0:09] 70 int i24[] = {1, 1, 0, 1}; [ 0:09] 71 int i25[] = {1, 1, 1, 0}; [ 0:09] 72 assert(std::is_heap(i11, i11+4) == (std::is_heap_until(i11, i11+4) == i11+4)); [ 0:09] 73 assert(std::is_heap(i12, i12+4) == (std::is_heap_until(i12, i12+4) == i12+4)); [ 0:09] 74 assert(std::is_heap(i13, i13+4) == (std::is_heap_until(i13, i13+4) == i13+4)); [ 0:09] 75 assert(std::is_heap(i14, i14+4) == (std::is_heap_until(i14, i14+4) == i14+4)); [ 0:09] 76 assert(std::is_heap(i15, i15+4) == (std::is_heap_until(i15, i15+4) == i15+4)); [ 0:09] 77 assert(std::is_heap(i16, i16+4) == (std::is_heap_until(i16, i16+4) == i16+4)); [ 0:09] 78 assert(std::is_heap(i17, i17+4) == (std::is_heap_until(i17, i17+4) == i17+4)); [ 0:09] 79 assert(std::is_heap(i18, i18+4) == (std::is_heap_until(i18, i18+4) == i18+4)); [ 0:09] 80 assert(std::is_heap(i19, i19+4) == (std::is_heap_until(i19, i19+4) == i19+4)); [ 0:09] 81 assert(std::is_heap(i20, i20+4) == (std::is_heap_until(i20, i20+4) == i20+4)); [ 0:09] 82 assert(std::is_heap(i21, i21+4) == (std::is_heap_until(i21, i21+4) == i21+4)); [ 0:09] 83 assert(std::is_heap(i22, i22+4) == (std::is_heap_until(i22, i22+4) == i22+4)); [ 0:09] 84 assert(std::is_heap(i23, i23+4) == (std::is_heap_until(i23, i23+4) == i23+4)); [ 0:09] 85 assert(std::is_heap(i24, i24+4) == (std::is_heap_until(i24, i24+4) == i24+4)); [ 0:09] 86 assert(std::is_heap(i25, i25+4) == (std::is_heap_until(i25, i25+4) == i25+4)); [ 0:09] 87 int i26[] = {0, 0, 0, 0, 0}; [ 0:09] 88 int i27[] = {0, 0, 0, 0, 1}; [ 0:09] 89 int i28[] = {0, 0, 0, 1, 0}; [ 0:09] 90 int i29[] = {0, 0, 0, 1, 1}; [ 0:09] 91 int i30[] = {0, 0, 1, 0, 0}; [ 0:09] 92 int i31[] = {0, 0, 1, 0, 1}; [ 0:09] 93 int i32[] = {0, 0, 1, 1, 0}; [ 0:09] 94 int i33[] = {0, 0, 1, 1, 1}; [ 0:09] 95 int i34[] = {0, 1, 0, 0, 0}; [ 0:09] 96 int i35[] = {0, 1, 0, 0, 1}; [ 0:09] 97 int i36[] = {0, 1, 0, 1, 0}; [ 0:09] 98 int i37[] = {0, 1, 0, 1, 1}; [ 0:09] 99 int i38[] = {0, 1, 1, 0, 0}; [ 0:09] 100 int i39[] = {0, 1, 1, 0, 1}; [ 0:09] 101 int i40[] = {0, 1, 1, 1, 0}; [ 0:09] 102 int i41[] = {0, 1, 1, 1, 1}; [ 0:09] 103 int i42[] = {1, 0, 0, 0, 0}; [ 0:09] 104 int i43[] = {1, 0, 0, 0, 1}; [ 0:09] 105 int i44[] = {1, 0, 0, 1, 0}; [ 0:09] 106 int i45[] = {1, 0, 0, 1, 1}; [ 0:09] 107 int i46[] = {1, 0, 1, 0, 0}; [ 0:09] 108 int i47[] = {1, 0, 1, 0, 1}; [ 0:09] 109 int i48[] = {1, 0, 1, 1, 0}; [ 0:09] 110 int i49[] = {1, 0, 1, 1, 1}; [ 0:09] 111 int i50[] = {1, 1, 0, 0, 0}; [ 0:09] 112 int i51[] = {1, 1, 0, 0, 1}; [ 0:09] 113 int i52[] = {1, 1, 0, 1, 0}; [ 0:09] 114 int i53[] = {1, 1, 0, 1, 1}; [ 0:09] 115 int i54[] = {1, 1, 1, 0, 0}; [ 0:09] 116 int i55[] = {1, 1, 1, 0, 1}; [ 0:09] 117 int i56[] = {1, 1, 1, 1, 0}; [ 0:09] 118 assert(std::is_heap(i26, i26+5) == (std::is_heap_until(i26, i26+5) == i26+5)); [ 0:09] 119 assert(std::is_heap(i27, i27+5) == (std::is_heap_until(i27, i27+5) == i27+5)); [ 0:09] 120 assert(std::is_heap(i28, i28+5) == (std::is_heap_until(i28, i28+5) == i28+5)); [ 0:09] 121 assert(std::is_heap(i29, i29+5) == (std::is_heap_until(i29, i29+5) == i29+5)); [ 0:09] 122 assert(std::is_heap(i30, i30+5) == (std::is_heap_until(i30, i30+5) == i30+5)); [ 0:09] 123 assert(std::is_heap(i31, i31+5) == (std::is_heap_until(i31, i31+5) == i31+5)); [ 0:09] 124 assert(std::is_heap(i32, i32+5) == (std::is_heap_until(i32, i32+5) == i32+5)); [ 0:09] 125 assert(std::is_heap(i33, i33+5) == (std::is_heap_until(i33, i33+5) == i33+5)); [ 0:09] 126 assert(std::is_heap(i34, i34+5) == (std::is_heap_until(i34, i34+5) == i34+5)); [ 0:09] 127 assert(std::is_heap(i35, i35+5) == (std::is_heap_until(i35, i35+5) == i35+5)); [ 0:09] 128 assert(std::is_heap(i36, i36+5) == (std::is_heap_until(i36, i36+5) == i36+5)); [ 0:09] 129 assert(std::is_heap(i37, i37+5) == (std::is_heap_until(i37, i37+5) == i37+5)); [ 0:09] 130 assert(std::is_heap(i38, i38+5) == (std::is_heap_until(i38, i38+5) == i38+5)); [ 0:09] 131 assert(std::is_heap(i39, i39+5) == (std::is_heap_until(i39, i39+5) == i39+5)); [ 0:09] 132 assert(std::is_heap(i40, i40+5) == (std::is_heap_until(i40, i40+5) == i40+5)); [ 0:09] 133 assert(std::is_heap(i41, i41+5) == (std::is_heap_until(i41, i41+5) == i41+5)); [ 0:09] 134 assert(std::is_heap(i42, i42+5) == (std::is_heap_until(i42, i42+5) == i42+5)); [ 0:09] 135 assert(std::is_heap(i43, i43+5) == (std::is_heap_until(i43, i43+5) == i43+5)); [ 0:09] 136 assert(std::is_heap(i44, i44+5) == (std::is_heap_until(i44, i44+5) == i44+5)); [ 0:09] 137 assert(std::is_heap(i45, i45+5) == (std::is_heap_until(i45, i45+5) == i45+5)); [ 0:09] 138 assert(std::is_heap(i46, i46+5) == (std::is_heap_until(i46, i46+5) == i46+5)); [ 0:09] 139 assert(std::is_heap(i47, i47+5) == (std::is_heap_until(i47, i47+5) == i47+5)); [ 0:09] 140 assert(std::is_heap(i48, i48+5) == (std::is_heap_until(i48, i48+5) == i48+5)); [ 0:09] 141 assert(std::is_heap(i49, i49+5) == (std::is_heap_until(i49, i49+5) == i49+5)); [ 0:09] 142 assert(std::is_heap(i50, i50+5) == (std::is_heap_until(i50, i50+5) == i50+5)); [ 0:09] 143 assert(std::is_heap(i51, i51+5) == (std::is_heap_until(i51, i51+5) == i51+5)); [ 0:09] 144 assert(std::is_heap(i52, i52+5) == (std::is_heap_until(i52, i52+5) == i52+5)); [ 0:09] 145 assert(std::is_heap(i53, i53+5) == (std::is_heap_until(i53, i53+5) == i53+5)); [ 0:09] 146 assert(std::is_heap(i54, i54+5) == (std::is_heap_until(i54, i54+5) == i54+5)); [ 0:09] 147 assert(std::is_heap(i55, i55+5) == (std::is_heap_until(i55, i55+5) == i55+5)); [ 0:09] 148 assert(std::is_heap(i56, i56+5) == (std::is_heap_until(i56, i56+5) == i56+5)); [ 0:09] 149 int i57[] = {0, 0, 0, 0, 0, 0}; [ 0:09] 150 int i58[] = {0, 0, 0, 0, 0, 1}; [ 0:09] 151 int i59[] = {0, 0, 0, 0, 1, 0}; [ 0:09] 152 int i60[] = {0, 0, 0, 0, 1, 1}; [ 0:09] 153 int i61[] = {0, 0, 0, 1, 0, 0}; [ 0:09] 154 int i62[] = {0, 0, 0, 1, 0, 1}; [ 0:09] 155 int i63[] = {0, 0, 0, 1, 1, 0}; [ 0:09] 156 int i64[] = {0, 0, 0, 1, 1, 1}; [ 0:09] 157 int i65[] = {0, 0, 1, 0, 0, 0}; [ 0:09] 158 int i66[] = {0, 0, 1, 0, 0, 1}; [ 0:09] 159 int i67[] = {0, 0, 1, 0, 1, 0}; [ 0:09] 160 int i68[] = {0, 0, 1, 0, 1, 1}; [ 0:09] 161 int i69[] = {0, 0, 1, 1, 0, 0}; [ 0:09] 162 int i70[] = {0, 0, 1, 1, 0, 1}; [ 0:09] 163 int i71[] = {0, 0, 1, 1, 1, 0}; [ 0:09] 164 int i72[] = {0, 0, 1, 1, 1, 1}; [ 0:09] 165 int i73[] = {0, 1, 0, 0, 0, 0}; [ 0:09] 166 int i74[] = {0, 1, 0, 0, 0, 1}; [ 0:09] 167 int i75[] = {0, 1, 0, 0, 1, 0}; [ 0:09] 168 int i76[] = {0, 1, 0, 0, 1, 1}; [ 0:09] 169 int i77[] = {0, 1, 0, 1, 0, 0}; [ 0:09] 170 int i78[] = {0, 1, 0, 1, 0, 1}; [ 0:09] 171 int i79[] = {0, 1, 0, 1, 1, 0}; [ 0:09] 172 int i80[] = {0, 1, 0, 1, 1, 1}; [ 0:09] 173 int i81[] = {0, 1, 1, 0, 0, 0}; [ 0:09] 174 int i82[] = {0, 1, 1, 0, 0, 1}; [ 0:09] 175 int i83[] = {0, 1, 1, 0, 1, 0}; [ 0:09] 176 int i84[] = {0, 1, 1, 0, 1, 1}; [ 0:09] 177 int i85[] = {0, 1, 1, 1, 0, 0}; [ 0:09] 178 int i86[] = {0, 1, 1, 1, 0, 1}; [ 0:09] 179 int i87[] = {0, 1, 1, 1, 1, 0}; [ 0:09] 180 int i88[] = {0, 1, 1, 1, 1, 1}; [ 0:09] 181 int i89[] = {1, 0, 0, 0, 0, 0}; [ 0:09] 182 int i90[] = {1, 0, 0, 0, 0, 1}; [ 0:09] 183 int i91[] = {1, 0, 0, 0, 1, 0}; [ 0:09] 184 int i92[] = {1, 0, 0, 0, 1, 1}; [ 0:09] 185 int i93[] = {1, 0, 0, 1, 0, 0}; [ 0:09] 186 int i94[] = {1, 0, 0, 1, 0, 1}; [ 0:09] 187 int i95[] = {1, 0, 0, 1, 1, 0}; [ 0:09] 188 int i96[] = {1, 0, 0, 1, 1, 1}; [ 0:09] 189 int i97[] = {1, 0, 1, 0, 0, 0}; [ 0:09] 190 int i98[] = {1, 0, 1, 0, 0, 1}; [ 0:09] 191 int i99[] = {1, 0, 1, 0, 1, 0}; [ 0:09] 192 int i100[] = {1, 0, 1, 0, 1, 1}; [ 0:09] 193 int i101[] = {1, 0, 1, 1, 0, 0}; [ 0:09] 194 int i102[] = {1, 0, 1, 1, 0, 1}; [ 0:09] 195 int i103[] = {1, 0, 1, 1, 1, 0}; [ 0:09] 196 int i104[] = {1, 0, 1, 1, 1, 1}; [ 0:09] 197 int i105[] = {1, 1, 0, 0, 0, 0}; [ 0:09] 198 int i106[] = {1, 1, 0, 0, 0, 1}; [ 0:09] 199 int i107[] = {1, 1, 0, 0, 1, 0}; [ 0:09] 200 int i108[] = {1, 1, 0, 0, 1, 1}; [ 0:09] 201 int i109[] = {1, 1, 0, 1, 0, 0}; [ 0:09] 202 int i110[] = {1, 1, 0, 1, 0, 1}; [ 0:09] 203 int i111[] = {1, 1, 0, 1, 1, 0}; [ 0:09] 204 int i112[] = {1, 1, 0, 1, 1, 1}; [ 0:09] 205 int i113[] = {1, 1, 1, 0, 0, 0}; [ 0:09] 206 int i114[] = {1, 1, 1, 0, 0, 1}; [ 0:09] 207 int i115[] = {1, 1, 1, 0, 1, 0}; [ 0:09] 208 int i116[] = {1, 1, 1, 0, 1, 1}; [ 0:09] 209 int i117[] = {1, 1, 1, 1, 0, 0}; [ 0:09] 210 int i118[] = {1, 1, 1, 1, 0, 1}; [ 0:09] 211 int i119[] = {1, 1, 1, 1, 1, 0}; [ 0:09] 212 assert(std::is_heap(i57, i57+6) == (std::is_heap_until(i57, i57+6) == i57+6)); [ 0:09] 213 assert(std::is_heap(i58, i58+6) == (std::is_heap_until(i58, i58+6) == i58+6)); [ 0:09] 214 assert(std::is_heap(i59, i59+6) == (std::is_heap_until(i59, i59+6) == i59+6)); [ 0:09] 215 assert(std::is_heap(i60, i60+6) == (std::is_heap_until(i60, i60+6) == i60+6)); [ 0:09] 216 assert(std::is_heap(i61, i61+6) == (std::is_heap_until(i61, i61+6) == i61+6)); [ 0:09] 217 assert(std::is_heap(i62, i62+6) == (std::is_heap_until(i62, i62+6) == i62+6)); [ 0:09] 218 assert(std::is_heap(i63, i63+6) == (std::is_heap_until(i63, i63+6) == i63+6)); [ 0:09] 219 assert(std::is_heap(i64, i64+6) == (std::is_heap_until(i64, i64+6) == i64+6)); [ 0:09] 220 assert(std::is_heap(i65, i65+6) == (std::is_heap_until(i65, i65+6) == i65+6)); [ 0:09] 221 assert(std::is_heap(i66, i66+6) == (std::is_heap_until(i66, i66+6) == i66+6)); [ 0:09] 222 assert(std::is_heap(i67, i67+6) == (std::is_heap_until(i67, i67+6) == i67+6)); [ 0:09] 223 assert(std::is_heap(i68, i68+6) == (std::is_heap_until(i68, i68+6) == i68+6)); [ 0:09] 224 assert(std::is_heap(i69, i69+6) == (std::is_heap_until(i69, i69+6) == i69+6)); [ 0:09] 225 assert(std::is_heap(i70, i70+6) == (std::is_heap_until(i70, i70+6) == i70+6)); [ 0:09] 226 assert(std::is_heap(i71, i71+6) == (std::is_heap_until(i71, i71+6) == i71+6)); [ 0:09] 227 assert(std::is_heap(i72, i72+6) == (std::is_heap_until(i72, i72+6) == i72+6)); [ 0:09] 228 assert(std::is_heap(i73, i73+6) == (std::is_heap_until(i73, i73+6) == i73+6)); [ 0:09] 229 assert(std::is_heap(i74, i74+6) == (std::is_heap_until(i74, i74+6) == i74+6)); [ 0:09] 230 assert(std::is_heap(i75, i75+6) == (std::is_heap_until(i75, i75+6) == i75+6)); [ 0:09] 231 assert(std::is_heap(i76, i76+6) == (std::is_heap_until(i76, i76+6) == i76+6)); [ 0:09] 232 assert(std::is_heap(i77, i77+6) == (std::is_heap_until(i77, i77+6) == i77+6)); [ 0:09] 233 assert(std::is_heap(i78, i78+6) == (std::is_heap_until(i78, i78+6) == i78+6)); [ 0:09] 234 assert(std::is_heap(i79, i79+6) == (std::is_heap_until(i79, i79+6) == i79+6)); [ 0:09] 235 assert(std::is_heap(i80, i80+6) == (std::is_heap_until(i80, i80+6) == i80+6)); [ 0:09] 236 assert(std::is_heap(i81, i81+6) == (std::is_heap_until(i81, i81+6) == i81+6)); [ 0:09] 237 assert(std::is_heap(i82, i82+6) == (std::is_heap_until(i82, i82+6) == i82+6)); [ 0:09] 238 assert(std::is_heap(i83, i83+6) == (std::is_heap_until(i83, i83+6) == i83+6)); [ 0:09] 239 assert(std::is_heap(i84, i84+6) == (std::is_heap_until(i84, i84+6) == i84+6)); [ 0:09] 240 assert(std::is_heap(i85, i85+6) == (std::is_heap_until(i85, i85+6) == i85+6)); [ 0:09] 241 assert(std::is_heap(i86, i86+6) == (std::is_heap_until(i86, i86+6) == i86+6)); [ 0:09] 242 assert(std::is_heap(i87, i87+6) == (std::is_heap_until(i87, i87+6) == i87+6)); [ 0:09] 243 assert(std::is_heap(i88, i88+6) == (std::is_heap_until(i88, i88+6) == i88+6)); [ 0:09] 244 assert(std::is_heap(i89, i89+6) == (std::is_heap_until(i89, i89+6) == i89+6)); [ 0:09] 245 assert(std::is_heap(i90, i90+6) == (std::is_heap_until(i90, i90+6) == i90+6)); [ 0:09] 246 assert(std::is_heap(i91, i91+6) == (std::is_heap_until(i91, i91+6) == i91+6)); [ 0:09] 247 assert(std::is_heap(i92, i92+6) == (std::is_heap_until(i92, i92+6) == i92+6)); [ 0:09] 248 assert(std::is_heap(i93, i93+6) == (std::is_heap_until(i93, i93+6) == i93+6)); [ 0:09] 249 assert(std::is_heap(i94, i94+6) == (std::is_heap_until(i94, i94+6) == i94+6)); [ 0:09] 250 assert(std::is_heap(i95, i95+6) == (std::is_heap_until(i95, i95+6) == i95+6)); [ 0:09] 251 assert(std::is_heap(i96, i96+6) == (std::is_heap_until(i96, i96+6) == i96+6)); [ 0:09] 252 assert(std::is_heap(i97, i97+6) == (std::is_heap_until(i97, i97+6) == i97+6)); [ 0:09] 253 assert(std::is_heap(i98, i98+6) == (std::is_heap_until(i98, i98+6) == i98+6)); [ 0:09] 254 assert(std::is_heap(i99, i99+6) == (std::is_heap_until(i99, i99+6) == i99+6)); [ 0:09] 255 assert(std::is_heap(i100, i100+6) == (std::is_heap_until(i100, i100+6) == i100+6)); [ 0:09] 256 assert(std::is_heap(i101, i101+6) == (std::is_heap_until(i101, i101+6) == i101+6)); [ 0:09] 257 assert(std::is_heap(i102, i102+6) == (std::is_heap_until(i102, i102+6) == i102+6)); [ 0:09] 258 assert(std::is_heap(i103, i103+6) == (std::is_heap_until(i103, i103+6) == i103+6)); [ 0:09] 259 assert(std::is_heap(i104, i104+6) == (std::is_heap_until(i104, i104+6) == i104+6)); [ 0:09] 260 assert(std::is_heap(i105, i105+6) == (std::is_heap_until(i105, i105+6) == i105+6)); [ 0:09] 261 assert(std::is_heap(i106, i106+6) == (std::is_heap_until(i106, i106+6) == i106+6)); [ 0:09] 262 assert(std::is_heap(i107, i107+6) == (std::is_heap_until(i107, i107+6) == i107+6)); [ 0:09] 263 assert(std::is_heap(i108, i108+6) == (std::is_heap_until(i108, i108+6) == i108+6)); [ 0:09] 264 assert(std::is_heap(i109, i109+6) == (std::is_heap_until(i109, i109+6) == i109+6)); [ 0:09] 265 assert(std::is_heap(i110, i110+6) == (std::is_heap_until(i110, i110+6) == i110+6)); [ 0:09] 266 assert(std::is_heap(i111, i111+6) == (std::is_heap_until(i111, i111+6) == i111+6)); [ 0:09] 267 assert(std::is_heap(i112, i112+6) == (std::is_heap_until(i112, i112+6) == i112+6)); [ 0:09] 268 assert(std::is_heap(i113, i113+6) == (std::is_heap_until(i113, i113+6) == i113+6)); [ 0:09] 269 assert(std::is_heap(i114, i114+6) == (std::is_heap_until(i114, i114+6) == i114+6)); [ 0:09] 270 assert(std::is_heap(i115, i115+6) == (std::is_heap_until(i115, i115+6) == i115+6)); [ 0:09] 271 assert(std::is_heap(i116, i116+6) == (std::is_heap_until(i116, i116+6) == i116+6)); [ 0:09] 272 assert(std::is_heap(i117, i117+6) == (std::is_heap_until(i117, i117+6) == i117+6)); [ 0:09] 273 assert(std::is_heap(i118, i118+6) == (std::is_heap_until(i118, i118+6) == i118+6)); [ 0:09] 274 assert(std::is_heap(i119, i119+6) == (std::is_heap_until(i119, i119+6) == i119+6)); [ 0:09] 275 int i120[] = {0, 0, 0, 0, 0, 0, 0}; [ 0:09] 276 int i121[] = {0, 0, 0, 0, 0, 0, 1}; [ 0:09] 277 int i122[] = {0, 0, 0, 0, 0, 1, 0}; [ 0:09] 278 int i123[] = {0, 0, 0, 0, 0, 1, 1}; [ 0:09] 279 int i124[] = {0, 0, 0, 0, 1, 0, 0}; [ 0:09] 280 int i125[] = {0, 0, 0, 0, 1, 0, 1}; [ 0:09] 281 int i126[] = {0, 0, 0, 0, 1, 1, 0}; [ 0:09] 282 int i127[] = {0, 0, 0, 0, 1, 1, 1}; [ 0:09] 283 int i128[] = {0, 0, 0, 1, 0, 0, 0}; [ 0:09] 284 int i129[] = {0, 0, 0, 1, 0, 0, 1}; [ 0:09] 285 int i130[] = {0, 0, 0, 1, 0, 1, 0}; [ 0:09] 286 int i131[] = {0, 0, 0, 1, 0, 1, 1}; [ 0:09] 287 int i132[] = {0, 0, 0, 1, 1, 0, 0}; [ 0:09] 288 int i133[] = {0, 0, 0, 1, 1, 0, 1}; [ 0:09] 289 int i134[] = {0, 0, 0, 1, 1, 1, 0}; [ 0:09] 290 int i135[] = {0, 0, 0, 1, 1, 1, 1}; [ 0:09] 291 int i136[] = {0, 0, 1, 0, 0, 0, 0}; [ 0:09] 292 int i137[] = {0, 0, 1, 0, 0, 0, 1}; [ 0:09] 293 int i138[] = {0, 0, 1, 0, 0, 1, 0}; [ 0:09] 294 int i139[] = {0, 0, 1, 0, 0, 1, 1}; [ 0:09] 295 int i140[] = {0, 0, 1, 0, 1, 0, 0}; [ 0:09] 296 int i141[] = {0, 0, 1, 0, 1, 0, 1}; [ 0:09] 297 int i142[] = {0, 0, 1, 0, 1, 1, 0}; [ 0:09] 298 int i143[] = {0, 0, 1, 0, 1, 1, 1}; [ 0:09] 299 int i144[] = {0, 0, 1, 1, 0, 0, 0}; [ 0:09] 300 int i145[] = {0, 0, 1, 1, 0, 0, 1}; [ 0:09] 301 int i146[] = {0, 0, 1, 1, 0, 1, 0}; [ 0:09] 302 int i147[] = {0, 0, 1, 1, 0, 1, 1}; [ 0:09] 303 int i148[] = {0, 0, 1, 1, 1, 0, 0}; [ 0:09] 304 int i149[] = {0, 0, 1, 1, 1, 0, 1}; [ 0:09] 305 int i150[] = {0, 0, 1, 1, 1, 1, 0}; [ 0:09] 306 int i151[] = {0, 0, 1, 1, 1, 1, 1}; [ 0:09] 307 int i152[] = {0, 1, 0, 0, 0, 0, 0}; [ 0:09] 308 int i153[] = {0, 1, 0, 0, 0, 0, 1}; [ 0:09] 309 int i154[] = {0, 1, 0, 0, 0, 1, 0}; [ 0:09] 310 int i155[] = {0, 1, 0, 0, 0, 1, 1}; [ 0:09] 311 int i156[] = {0, 1, 0, 0, 1, 0, 0}; [ 0:09] 312 int i157[] = {0, 1, 0, 0, 1, 0, 1}; [ 0:09] 313 int i158[] = {0, 1, 0, 0, 1, 1, 0}; [ 0:09] 314 int i159[] = {0, 1, 0, 0, 1, 1, 1}; [ 0:09] 315 int i160[] = {0, 1, 0, 1, 0, 0, 0}; [ 0:09] 316 int i161[] = {0, 1, 0, 1, 0, 0, 1}; [ 0:09] 317 int i162[] = {0, 1, 0, 1, 0, 1, 0}; [ 0:09] 318 int i163[] = {0, 1, 0, 1, 0, 1, 1}; [ 0:09] 319 int i164[] = {0, 1, 0, 1, 1, 0, 0}; [ 0:09] 320 int i165[] = {0, 1, 0, 1, 1, 0, 1}; [ 0:09] 321 int i166[] = {0, 1, 0, 1, 1, 1, 0}; [ 0:09] 322 int i167[] = {0, 1, 0, 1, 1, 1, 1}; [ 0:09] 323 int i168[] = {0, 1, 1, 0, 0, 0, 0}; [ 0:09] 324 int i169[] = {0, 1, 1, 0, 0, 0, 1}; [ 0:09] 325 int i170[] = {0, 1, 1, 0, 0, 1, 0}; [ 0:09] 326 int i171[] = {0, 1, 1, 0, 0, 1, 1}; [ 0:09] 327 int i172[] = {0, 1, 1, 0, 1, 0, 0}; [ 0:09] 328 int i173[] = {0, 1, 1, 0, 1, 0, 1}; [ 0:09] 329 int i174[] = {0, 1, 1, 0, 1, 1, 0}; [ 0:09] 330 int i175[] = {0, 1, 1, 0, 1, 1, 1}; [ 0:09] 331 int i176[] = {0, 1, 1, 1, 0, 0, 0}; [ 0:09] 332 int i177[] = {0, 1, 1, 1, 0, 0, 1}; [ 0:09] 333 int i178[] = {0, 1, 1, 1, 0, 1, 0}; [ 0:09] 334 int i179[] = {0, 1, 1, 1, 0, 1, 1}; [ 0:09] 335 int i180[] = {0, 1, 1, 1, 1, 0, 0}; [ 0:09] 336 int i181[] = {0, 1, 1, 1, 1, 0, 1}; [ 0:09] 337 int i182[] = {0, 1, 1, 1, 1, 1, 0}; [ 0:09] 338 int i183[] = {0, 1, 1, 1, 1, 1, 1}; [ 0:09] 339 int i184[] = {1, 0, 0, 0, 0, 0, 0}; [ 0:09] 340 int i185[] = {1, 0, 0, 0, 0, 0, 1}; [ 0:09] 341 int i186[] = {1, 0, 0, 0, 0, 1, 0}; [ 0:09] 342 int i187[] = {1, 0, 0, 0, 0, 1, 1}; [ 0:09] 343 int i188[] = {1, 0, 0, 0, 1, 0, 0}; [ 0:09] 344 int i189[] = {1, 0, 0, 0, 1, 0, 1}; [ 0:09] 345 int i190[] = {1, 0, 0, 0, 1, 1, 0}; [ 0:09] 346 int i191[] = {1, 0, 0, 0, 1, 1, 1}; [ 0:09] 347 int i192[] = {1, 0, 0, 1, 0, 0, 0}; [ 0:09] 348 int i193[] = {1, 0, 0, 1, 0, 0, 1}; [ 0:09] 349 int i194[] = {1, 0, 0, 1, 0, 1, 0}; [ 0:09] 350 int i195[] = {1, 0, 0, 1, 0, 1, 1}; [ 0:09] 351 int i196[] = {1, 0, 0, 1, 1, 0, 0}; [ 0:09] 352 int i197[] = {1, 0, 0, 1, 1, 0, 1}; [ 0:09] 353 int i198[] = {1, 0, 0, 1, 1, 1, 0}; [ 0:09] 354 int i199[] = {1, 0, 0, 1, 1, 1, 1}; [ 0:09] 355 int i200[] = {1, 0, 1, 0, 0, 0, 0}; [ 0:09] 356 int i201[] = {1, 0, 1, 0, 0, 0, 1}; [ 0:09] 357 int i202[] = {1, 0, 1, 0, 0, 1, 0}; [ 0:09] 358 int i203[] = {1, 0, 1, 0, 0, 1, 1}; [ 0:09] 359 int i204[] = {1, 0, 1, 0, 1, 0, 0}; [ 0:09] 360 int i205[] = {1, 0, 1, 0, 1, 0, 1}; [ 0:09] 361 int i206[] = {1, 0, 1, 0, 1, 1, 0}; [ 0:09] 362 int i207[] = {1, 0, 1, 0, 1, 1, 1}; [ 0:09] 363 int i208[] = {1, 0, 1, 1, 0, 0, 0}; [ 0:09] 364 int i209[] = {1, 0, 1, 1, 0, 0, 1}; [ 0:09] 365 int i210[] = {1, 0, 1, 1, 0, 1, 0}; [ 0:09] 366 int i211[] = {1, 0, 1, 1, 0, 1, 1}; [ 0:09] 367 int i212[] = {1, 0, 1, 1, 1, 0, 0}; [ 0:09] 368 int i213[] = {1, 0, 1, 1, 1, 0, 1}; [ 0:09] 369 int i214[] = {1, 0, 1, 1, 1, 1, 0}; [ 0:09] 370 int i215[] = {1, 0, 1, 1, 1, 1, 1}; [ 0:09] 371 int i216[] = {1, 1, 0, 0, 0, 0, 0}; [ 0:09] 372 int i217[] = {1, 1, 0, 0, 0, 0, 1}; [ 0:09] 373 int i218[] = {1, 1, 0, 0, 0, 1, 0}; [ 0:09] 374 int i219[] = {1, 1, 0, 0, 0, 1, 1}; [ 0:09] 375 int i220[] = {1, 1, 0, 0, 1, 0, 0}; [ 0:09] 376 int i221[] = {1, 1, 0, 0, 1, 0, 1}; [ 0:09] 377 int i222[] = {1, 1, 0, 0, 1, 1, 0}; [ 0:09] 378 int i223[] = {1, 1, 0, 0, 1, 1, 1}; [ 0:09] 379 int i224[] = {1, 1, 0, 1, 0, 0, 0}; [ 0:09] 380 int i225[] = {1, 1, 0, 1, 0, 0, 1}; [ 0:09] 381 int i226[] = {1, 1, 0, 1, 0, 1, 0}; [ 0:09] 382 int i227[] = {1, 1, 0, 1, 0, 1, 1}; [ 0:09] 383 int i228[] = {1, 1, 0, 1, 1, 0, 0}; [ 0:09] 384 int i229[] = {1, 1, 0, 1, 1, 0, 1}; [ 0:09] 385 int i230[] = {1, 1, 0, 1, 1, 1, 0}; [ 0:09] 386 int i231[] = {1, 1, 0, 1, 1, 1, 1}; [ 0:09] 387 int i232[] = {1, 1, 1, 0, 0, 0, 0}; [ 0:09] 388 int i233[] = {1, 1, 1, 0, 0, 0, 1}; [ 0:09] 389 int i234[] = {1, 1, 1, 0, 0, 1, 0}; [ 0:09] 390 int i235[] = {1, 1, 1, 0, 0, 1, 1}; [ 0:09] 391 int i236[] = {1, 1, 1, 0, 1, 0, 0}; [ 0:09] 392 int i237[] = {1, 1, 1, 0, 1, 0, 1}; [ 0:09] 393 int i238[] = {1, 1, 1, 0, 1, 1, 0}; [ 0:09] 394 int i239[] = {1, 1, 1, 0, 1, 1, 1}; [ 0:09] 395 int i240[] = {1, 1, 1, 1, 0, 0, 0}; [ 0:09] 396 int i241[] = {1, 1, 1, 1, 0, 0, 1}; [ 0:09] 397 int i242[] = {1, 1, 1, 1, 0, 1, 0}; [ 0:09] 398 int i243[] = {1, 1, 1, 1, 0, 1, 1}; [ 0:09] 399 int i244[] = {1, 1, 1, 1, 1, 0, 0}; [ 0:09] 400 int i245[] = {1, 1, 1, 1, 1, 0, 1}; [ 0:09] 401 int i246[] = {1, 1, 1, 1, 1, 1, 0}; [ 0:09] 402 assert(std::is_heap(i120, i120+7) == (std::is_heap_until(i120, i120+7) == i120+7)); [ 0:09] 403 assert(std::is_heap(i121, i121+7) == (std::is_heap_until(i121, i121+7) == i121+7)); [ 0:09] 404 assert(std::is_heap(i122, i122+7) == (std::is_heap_until(i122, i122+7) == i122+7)); [ 0:09] 405 assert(std::is_heap(i123, i123+7) == (std::is_heap_until(i123, i123+7) == i123+7)); [ 0:09] 406 assert(std::is_heap(i124, i124+7) == (std::is_heap_until(i124, i124+7) == i124+7)); [ 0:09] 407 assert(std::is_heap(i125, i125+7) == (std::is_heap_until(i125, i125+7) == i125+7)); [ 0:09] 408 assert(std::is_heap(i126, i126+7) == (std::is_heap_until(i126, i126+7) == i126+7)); [ 0:09] 409 assert(std::is_heap(i127, i127+7) == (std::is_heap_until(i127, i127+7) == i127+7)); [ 0:09] 410 assert(std::is_heap(i128, i128+7) == (std::is_heap_until(i128, i128+7) == i128+7)); [ 0:09] 411 assert(std::is_heap(i129, i129+7) == (std::is_heap_until(i129, i129+7) == i129+7)); [ 0:09] 412 assert(std::is_heap(i130, i130+7) == (std::is_heap_until(i130, i130+7) == i130+7)); [ 0:09] 413 assert(std::is_heap(i131, i131+7) == (std::is_heap_until(i131, i131+7) == i131+7)); [ 0:09] 414 assert(std::is_heap(i132, i132+7) == (std::is_heap_until(i132, i132+7) == i132+7)); [ 0:09] 415 assert(std::is_heap(i133, i133+7) == (std::is_heap_until(i133, i133+7) == i133+7)); [ 0:09] 416 assert(std::is_heap(i134, i134+7) == (std::is_heap_until(i134, i134+7) == i134+7)); [ 0:09] 417 assert(std::is_heap(i135, i135+7) == (std::is_heap_until(i135, i135+7) == i135+7)); [ 0:09] 418 assert(std::is_heap(i136, i136+7) == (std::is_heap_until(i136, i136+7) == i136+7)); [ 0:09] 419 assert(std::is_heap(i137, i137+7) == (std::is_heap_until(i137, i137+7) == i137+7)); [ 0:09] 420 assert(std::is_heap(i138, i138+7) == (std::is_heap_until(i138, i138+7) == i138+7)); [ 0:09] 421 assert(std::is_heap(i139, i139+7) == (std::is_heap_until(i139, i139+7) == i139+7)); [ 0:09] 422 assert(std::is_heap(i140, i140+7) == (std::is_heap_until(i140, i140+7) == i140+7)); [ 0:09] 423 assert(std::is_heap(i141, i141+7) == (std::is_heap_until(i141, i141+7) == i141+7)); [ 0:09] 424 assert(std::is_heap(i142, i142+7) == (std::is_heap_until(i142, i142+7) == i142+7)); [ 0:09] 425 assert(std::is_heap(i143, i143+7) == (std::is_heap_until(i143, i143+7) == i143+7)); [ 0:09] 426 assert(std::is_heap(i144, i144+7) == (std::is_heap_until(i144, i144+7) == i144+7)); [ 0:09] 427 assert(std::is_heap(i145, i145+7) == (std::is_heap_until(i145, i145+7) == i145+7)); [ 0:09] 428 assert(std::is_heap(i146, i146+7) == (std::is_heap_until(i146, i146+7) == i146+7)); [ 0:09] 429 assert(std::is_heap(i147, i147+7) == (std::is_heap_until(i147, i147+7) == i147+7)); [ 0:09] 430 assert(std::is_heap(i148, i148+7) == (std::is_heap_until(i148, i148+7) == i148+7)); [ 0:09] 431 assert(std::is_heap(i149, i149+7) == (std::is_heap_until(i149, i149+7) == i149+7)); [ 0:09] 432 assert(std::is_heap(i150, i150+7) == (std::is_heap_until(i150, i150+7) == i150+7)); [ 0:09] 433 assert(std::is_heap(i151, i151+7) == (std::is_heap_until(i151, i151+7) == i151+7)); [ 0:09] 434 assert(std::is_heap(i152, i152+7) == (std::is_heap_until(i152, i152+7) == i152+7)); [ 0:09] 435 assert(std::is_heap(i153, i153+7) == (std::is_heap_until(i153, i153+7) == i153+7)); [ 0:09] 436 assert(std::is_heap(i154, i154+7) == (std::is_heap_until(i154, i154+7) == i154+7)); [ 0:09] 437 assert(std::is_heap(i155, i155+7) == (std::is_heap_until(i155, i155+7) == i155+7)); [ 0:09] 438 assert(std::is_heap(i156, i156+7) == (std::is_heap_until(i156, i156+7) == i156+7)); [ 0:09] 439 assert(std::is_heap(i157, i157+7) == (std::is_heap_until(i157, i157+7) == i157+7)); [ 0:09] 440 assert(std::is_heap(i158, i158+7) == (std::is_heap_until(i158, i158+7) == i158+7)); [ 0:09] 441 assert(std::is_heap(i159, i159+7) == (std::is_heap_until(i159, i159+7) == i159+7)); [ 0:09] 442 assert(std::is_heap(i160, i160+7) == (std::is_heap_until(i160, i160+7) == i160+7)); [ 0:09] 443 assert(std::is_heap(i161, i161+7) == (std::is_heap_until(i161, i161+7) == i161+7)); [ 0:09] 444 assert(std::is_heap(i162, i162+7) == (std::is_heap_until(i162, i162+7) == i162+7)); [ 0:09] 445 assert(std::is_heap(i163, i163+7) == (std::is_heap_until(i163, i163+7) == i163+7)); [ 0:09] 446 assert(std::is_heap(i164, i164+7) == (std::is_heap_until(i164, i164+7) == i164+7)); [ 0:09] 447 assert(std::is_heap(i165, i165+7) == (std::is_heap_until(i165, i165+7) == i165+7)); [ 0:09] 448 assert(std::is_heap(i166, i166+7) == (std::is_heap_until(i166, i166+7) == i166+7)); [ 0:09] 449 assert(std::is_heap(i167, i167+7) == (std::is_heap_until(i167, i167+7) == i167+7)); [ 0:09] 450 assert(std::is_heap(i168, i168+7) == (std::is_heap_until(i168, i168+7) == i168+7)); [ 0:09] 451 assert(std::is_heap(i169, i169+7) == (std::is_heap_until(i169, i169+7) == i169+7)); [ 0:09] 452 assert(std::is_heap(i170, i170+7) == (std::is_heap_until(i170, i170+7) == i170+7)); [ 0:09] 453 assert(std::is_heap(i171, i171+7) == (std::is_heap_until(i171, i171+7) == i171+7)); [ 0:09] 454 assert(std::is_heap(i172, i172+7) == (std::is_heap_until(i172, i172+7) == i172+7)); [ 0:09] 455 assert(std::is_heap(i173, i173+7) == (std::is_heap_until(i173, i173+7) == i173+7)); [ 0:09] 456 assert(std::is_heap(i174, i174+7) == (std::is_heap_until(i174, i174+7) == i174+7)); [ 0:09] 457 assert(std::is_heap(i175, i175+7) == (std::is_heap_until(i175, i175+7) == i175+7)); [ 0:09] 458 assert(std::is_heap(i176, i176+7) == (std::is_heap_until(i176, i176+7) == i176+7)); [ 0:09] 459 assert(std::is_heap(i177, i177+7) == (std::is_heap_until(i177, i177+7) == i177+7)); [ 0:09] 460 assert(std::is_heap(i178, i178+7) == (std::is_heap_until(i178, i178+7) == i178+7)); [ 0:09] 461 assert(std::is_heap(i179, i179+7) == (std::is_heap_until(i179, i179+7) == i179+7)); [ 0:09] 462 assert(std::is_heap(i180, i180+7) == (std::is_heap_until(i180, i180+7) == i180+7)); [ 0:09] 463 assert(std::is_heap(i181, i181+7) == (std::is_heap_until(i181, i181+7) == i181+7)); [ 0:09] 464 assert(std::is_heap(i182, i182+7) == (std::is_heap_until(i182, i182+7) == i182+7)); [ 0:09] 465 assert(std::is_heap(i183, i183+7) == (std::is_heap_until(i183, i183+7) == i183+7)); [ 0:09] 466 assert(std::is_heap(i184, i184+7) == (std::is_heap_until(i184, i184+7) == i184+7)); [ 0:09] 467 assert(std::is_heap(i185, i185+7) == (std::is_heap_until(i185, i185+7) == i185+7)); [ 0:09] 468 assert(std::is_heap(i186, i186+7) == (std::is_heap_until(i186, i186+7) == i186+7)); [ 0:09] 469 assert(std::is_heap(i187, i187+7) == (std::is_heap_until(i187, i187+7) == i187+7)); [ 0:09] 470 assert(std::is_heap(i188, i188+7) == (std::is_heap_until(i188, i188+7) == i188+7)); [ 0:09] 471 assert(std::is_heap(i189, i189+7) == (std::is_heap_until(i189, i189+7) == i189+7)); [ 0:09] 472 assert(std::is_heap(i190, i190+7) == (std::is_heap_until(i190, i190+7) == i190+7)); [ 0:09] 473 assert(std::is_heap(i191, i191+7) == (std::is_heap_until(i191, i191+7) == i191+7)); [ 0:09] 474 assert(std::is_heap(i192, i192+7) == (std::is_heap_until(i192, i192+7) == i192+7)); [ 0:09] 475 assert(std::is_heap(i193, i193+7) == (std::is_heap_until(i193, i193+7) == i193+7)); [ 0:09] 476 assert(std::is_heap(i194, i194+7) == (std::is_heap_until(i194, i194+7) == i194+7)); [ 0:09] 477 assert(std::is_heap(i195, i195+7) == (std::is_heap_until(i195, i195+7) == i195+7)); [ 0:09] 478 assert(std::is_heap(i196, i196+7) == (std::is_heap_until(i196, i196+7) == i196+7)); [ 0:09] 479 assert(std::is_heap(i197, i197+7) == (std::is_heap_until(i197, i197+7) == i197+7)); [ 0:09] 480 assert(std::is_heap(i198, i198+7) == (std::is_heap_until(i198, i198+7) == i198+7)); [ 0:09] 481 assert(std::is_heap(i199, i199+7) == (std::is_heap_until(i199, i199+7) == i199+7)); [ 0:09] 482 assert(std::is_heap(i200, i200+7) == (std::is_heap_until(i200, i200+7) == i200+7)); [ 0:09] 483 assert(std::is_heap(i201, i201+7) == (std::is_heap_until(i201, i201+7) == i201+7)); [ 0:09] 484 assert(std::is_heap(i202, i202+7) == (std::is_heap_until(i202, i202+7) == i202+7)); [ 0:09] 485 assert(std::is_heap(i203, i203+7) == (std::is_heap_until(i203, i203+7) == i203+7)); [ 0:09] 486 assert(std::is_heap(i204, i204+7) == (std::is_heap_until(i204, i204+7) == i204+7)); [ 0:09] 487 assert(std::is_heap(i205, i205+7) == (std::is_heap_until(i205, i205+7) == i205+7)); [ 0:09] 488 assert(std::is_heap(i206, i206+7) == (std::is_heap_until(i206, i206+7) == i206+7)); [ 0:09] 489 assert(std::is_heap(i207, i207+7) == (std::is_heap_until(i207, i207+7) == i207+7)); [ 0:09] 490 assert(std::is_heap(i208, i208+7) == (std::is_heap_until(i208, i208+7) == i208+7)); [ 0:09] 491 assert(std::is_heap(i209, i209+7) == (std::is_heap_until(i209, i209+7) == i209+7)); [ 0:09] 492 assert(std::is_heap(i210, i210+7) == (std::is_heap_until(i210, i210+7) == i210+7)); [ 0:09] 493 assert(std::is_heap(i211, i211+7) == (std::is_heap_until(i211, i211+7) == i211+7)); [ 0:09] 494 assert(std::is_heap(i212, i212+7) == (std::is_heap_until(i212, i212+7) == i212+7)); [ 0:09] 495 assert(std::is_heap(i213, i213+7) == (std::is_heap_until(i213, i213+7) == i213+7)); [ 0:09] 496 assert(std::is_heap(i214, i214+7) == (std::is_heap_until(i214, i214+7) == i214+7)); [ 0:09] 497 assert(std::is_heap(i215, i215+7) == (std::is_heap_until(i215, i215+7) == i215+7)); [ 0:09] 498 assert(std::is_heap(i216, i216+7) == (std::is_heap_until(i216, i216+7) == i216+7)); [ 0:09] 499 assert(std::is_heap(i217, i217+7) == (std::is_heap_until(i217, i217+7) == i217+7)); [ 0:09] 500 assert(std::is_heap(i218, i218+7) == (std::is_heap_until(i218, i218+7) == i218+7)); [ 0:09] 501 assert(std::is_heap(i219, i219+7) == (std::is_heap_until(i219, i219+7) == i219+7)); [ 0:09] 502 assert(std::is_heap(i220, i220+7) == (std::is_heap_until(i220, i220+7) == i220+7)); [ 0:09] 503 assert(std::is_heap(i221, i221+7) == (std::is_heap_until(i221, i221+7) == i221+7)); [ 0:09] 504 assert(std::is_heap(i222, i222+7) == (std::is_heap_until(i222, i222+7) == i222+7)); [ 0:09] 505 assert(std::is_heap(i223, i223+7) == (std::is_heap_until(i223, i223+7) == i223+7)); [ 0:09] 506 assert(std::is_heap(i224, i224+7) == (std::is_heap_until(i224, i224+7) == i224+7)); [ 0:09] 507 assert(std::is_heap(i225, i225+7) == (std::is_heap_until(i225, i225+7) == i225+7)); [ 0:09] 508 assert(std::is_heap(i226, i226+7) == (std::is_heap_until(i226, i226+7) == i226+7)); [ 0:09] 509 assert(std::is_heap(i227, i227+7) == (std::is_heap_until(i227, i227+7) == i227+7)); [ 0:09] 510 assert(std::is_heap(i228, i228+7) == (std::is_heap_until(i228, i228+7) == i228+7)); [ 0:09] 511 assert(std::is_heap(i229, i229+7) == (std::is_heap_until(i229, i229+7) == i229+7)); [ 0:09] 512 assert(std::is_heap(i230, i230+7) == (std::is_heap_until(i230, i230+7) == i230+7)); [ 0:09] 513 assert(std::is_heap(i231, i231+7) == (std::is_heap_until(i231, i231+7) == i231+7)); [ 0:09] 514 assert(std::is_heap(i232, i232+7) == (std::is_heap_until(i232, i232+7) == i232+7)); [ 0:09] 515 assert(std::is_heap(i233, i233+7) == (std::is_heap_until(i233, i233+7) == i233+7)); [ 0:09] 516 assert(std::is_heap(i234, i234+7) == (std::is_heap_until(i234, i234+7) == i234+7)); [ 0:09] 517 assert(std::is_heap(i235, i235+7) == (std::is_heap_until(i235, i235+7) == i235+7)); [ 0:09] 518 assert(std::is_heap(i236, i236+7) == (std::is_heap_until(i236, i236+7) == i236+7)); [ 0:09] 519 assert(std::is_heap(i237, i237+7) == (std::is_heap_until(i237, i237+7) == i237+7)); [ 0:09] 520 assert(std::is_heap(i238, i238+7) == (std::is_heap_until(i238, i238+7) == i238+7)); [ 0:09] 521 assert(std::is_heap(i239, i239+7) == (std::is_heap_until(i239, i239+7) == i239+7)); [ 0:09] 522 assert(std::is_heap(i240, i240+7) == (std::is_heap_until(i240, i240+7) == i240+7)); [ 0:09] 523 assert(std::is_heap(i241, i241+7) == (std::is_heap_until(i241, i241+7) == i241+7)); [ 0:09] 524 assert(std::is_heap(i242, i242+7) == (std::is_heap_until(i242, i242+7) == i242+7)); [ 0:09] 525 assert(std::is_heap(i243, i243+7) == (std::is_heap_until(i243, i243+7) == i243+7)); [ 0:09] 526 assert(std::is_heap(i244, i244+7) == (std::is_heap_until(i244, i244+7) == i244+7)); [ 0:09] 527 assert(std::is_heap(i245, i245+7) == (std::is_heap_until(i245, i245+7) == i245+7)); [ 0:09] 528 assert(std::is_heap(i246, i246+7) == (std::is_heap_until(i246, i246+7) == i246+7)); [ 0:09] 529 } [ 0:09] 530 [ 0:09] 531 int main(int, char**) [ 0:09] 532 { [ 0:09] 533 test(); [ 0:09] 534 [ 0:09] 535 #if TEST_STD_VER > 17 [ 0:09] 536 static_assert(test_constexpr()); [ 0:09] 537 #endif [ 0:09] 538 [ 0:09] 539 return 0; [ 0:09] 540 } [ 0:09] # no errors were expected but one was found anyway