; LLVM IR from erthink/libmdbx :: src (dpl)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.libmdbx_globals = type { %union.bin128, i32, i32, i8, i8, i8, i8, i32, %union.logger_union, %union.pthread_mutex_t, i64, ptr }
%union.bin128 = type { %struct.anon.6 }
%struct.anon.6 = type { i64, i64 }
%union.logger_union = type { ptr }
%union.pthread_mutex_t = type { %struct.__pthread_mutex_s }
%struct.__pthread_mutex_s = type { i32, i32, i32, i32, i32, i16, i16, %struct.__pthread_internal_list }
%struct.__pthread_internal_list = type { ptr, ptr }
%struct.MDBX_txn = type { i32, i32, i64, i64, ptr, ptr, %struct.geo, i64, i64, ptr, ptr, ptr, ptr, ptr, ptr, %struct.MDBX_canary, ptr, %union.anon.1 }
%struct.geo = type { i16, i16, i32, i32, %union.anon, %union.anon.0 }
%union.anon = type { i32 }
%union.anon.0 = type { i32 }
%struct.MDBX_canary = type { i64, i64, i64, i64 }
%union.anon.1 = type { %struct.anon.2 }
%struct.anon.2 = type { %struct.troika, ptr, %struct.anon.3, i8, i32, i32, i64, ptr, ptr, ptr, i64, %union.anon.4 }
%struct.troika = type { i8, i8, i8, i8, i32, [3 x i64] }
%struct.anon.3 = type { %struct.MDBX_rkl, i64, %struct.MDBX_rkl }
%struct.MDBX_rkl = type { i64, i64, i32, i32, ptr, [12 x i64] }
%union.anon.4 = type { %struct.anon.5 }
%struct.anon.5 = type { i64, ptr }
%struct.dpl = type { i64, i64, i64, i64, [18 x %struct.dp] }
%struct.dp = type { ptr, i32, i32 }

@globals = external global %struct.libmdbx_globals, align 8
@.str = external hidden unnamed_addr constant [36 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [39 x i8], align 1
@__func__.dpl_sort_slowpath = external hidden unnamed_addr constant [18 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [73 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [33 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [42 x i8], align 1

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare i64 @llvm.expect.i64(i64, i64) #0

; Function Attrs: noreturn
declare void @mdbx_assert_fail(ptr noundef, ptr noundef, ptr noundef, i32 noundef) #1

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #2

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #2

; Function Attrs: hot noinline nounwind uwtable
define dso_local ptr @dpl_sort_slowpath(ptr noundef %0) #3 {
  %2 = alloca ptr, align 8
  %3 = alloca ptr, align 8
  %4 = alloca i64, align 8
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca i8, align 1
  %13 = alloca i64, align 8
  store ptr %0, ptr %2, align 8, !tbaa !5
  br label %14

14:                                               ; preds = %1
  %15 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %16 = zext i8 %15 to i32
  %17 = and i32 %16, 1
  %18 = icmp ne i32 %17, 0
  %19 = xor i1 %18, true
  %20 = xor i1 %19, true
  %21 = zext i1 %20 to i32
  %22 = sext i32 %21 to i64
  %23 = call i64 @llvm.expect.i64(i64 %22, i64 1)
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %25, label %45

25:                                               ; preds = %14
  br label %26

26:                                               ; preds = %25
  %27 = load ptr, ptr %2, align 8, !tbaa !5
  %28 = getelementptr inbounds %struct.MDBX_txn, ptr %27, i32 0, i32 1
  %29 = load i32, ptr %28, align 4, !tbaa !14
  %30 = and i32 %29, 131072
  %31 = icmp eq i32 %30, 0
  %32 = xor i1 %31, true
  %33 = xor i1 %32, true
  %34 = xor i1 %33, true
  %35 = zext i1 %34 to i32
  %36 = sext i32 %35 to i64
  %37 = call i64 @llvm.expect.i64(i64 %36, i64 0)
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %39, label %43

39:                                               ; preds = %26
  %40 = load ptr, ptr %2, align 8, !tbaa !5
  %41 = getelementptr inbounds %struct.MDBX_txn, ptr %40, i32 0, i32 9
  %42 = load ptr, ptr %41, align 8, !tbaa !19
  call void @mdbx_assert_fail(ptr noundef %42, ptr noundef @.str, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 81) #6
  unreachable

43:                                               ; preds = %26
  br label %44

44:                                               ; preds = %43
  br label %45

45:                                               ; preds = %44, %14
  br label %46

46:                                               ; preds = %45
  br label %47

47:                                               ; preds = %46
  %48 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %49 = zext i8 %48 to i32
  %50 = and i32 %49, 1
  %51 = icmp ne i32 %50, 0
  %52 = xor i1 %51, true
  %53 = xor i1 %52, true
  %54 = zext i1 %53 to i32
  %55 = sext i32 %54 to i64
  %56 = call i64 @llvm.expect.i64(i64 %55, i64 1)
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %58, label %81

58:                                               ; preds = %47
  br label %59

59:                                               ; preds = %58
  %60 = load ptr, ptr %2, align 8, !tbaa !5
  %61 = getelementptr inbounds %struct.MDBX_txn, ptr %60, i32 0, i32 1
  %62 = load i32, ptr %61, align 4, !tbaa !14
  %63 = and i32 %62, 524288
  %64 = icmp eq i32 %63, 0
  br i1 %64, label %66, label %65

65:                                               ; preds = %59
  br label %66

66:                                               ; preds = %65, %59
  %67 = phi i1 [ true, %59 ], [ false, %65 ]
  %68 = xor i1 %67, true
  %69 = xor i1 %68, true
  %70 = xor i1 %69, true
  %71 = zext i1 %70 to i32
  %72 = sext i32 %71 to i64
  %73 = call i64 @llvm.expect.i64(i64 %72, i64 0)
  %74 = icmp ne i64 %73, 0
  br i1 %74, label %75, label %79

75:                                               ; preds = %66
  %76 = load ptr, ptr %2, align 8, !tbaa !5
  %77 = getelementptr inbounds %struct.MDBX_txn, ptr %76, i32 0, i32 9
  %78 = load ptr, ptr %77, align 8, !tbaa !19
  call void @mdbx_assert_fail(ptr noundef %78, ptr noundef @.str.1, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 82) #6
  unreachable

79:                                               ; preds = %66
  br label %80

80:                                               ; preds = %79
  br label %81

81:                                               ; preds = %80, %47
  br label %82

82:                                               ; preds = %81
  call void @llvm.lifetime.start.p0(i64 8, ptr %3) #7
  %83 = load ptr, ptr %2, align 8, !tbaa !5
  %84 = getelementptr inbounds %struct.MDBX_txn, ptr %83, i32 0, i32 17
  %85 = getelementptr inbounds %struct.anon.2, ptr %84, i32 0, i32 7
  %86 = load ptr, ptr %85, align 8, !tbaa !20
  store ptr %86, ptr %3, align 8, !tbaa !5
  br label %87

87:                                               ; preds = %82
  %88 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %89 = zext i8 %88 to i32
  %90 = and i32 %89, 1
  %91 = icmp ne i32 %90, 0
  %92 = xor i1 %91, true
  %93 = xor i1 %92, true
  %94 = zext i1 %93 to i32
  %95 = sext i32 %94 to i64
  %96 = call i64 @llvm.expect.i64(i64 %95, i64 1)
  %97 = icmp ne i64 %96, 0
  br i1 %97, label %98, label %130

98:                                               ; preds = %87
  br label %99

99:                                               ; preds = %98
  %100 = load ptr, ptr %3, align 8, !tbaa !5
  %101 = getelementptr inbounds %struct.dpl, ptr %100, i32 0, i32 4
  %102 = getelementptr inbounds [18 x %struct.dp], ptr %101, i64 0, i64 0
  %103 = getelementptr inbounds %struct.dp, ptr %102, i32 0, i32 1
  %104 = load i32, ptr %103, align 8, !tbaa !21
  %105 = icmp eq i32 %104, 0
  br i1 %105, label %106, label %117

106:                                              ; preds = %99
  %107 = load ptr, ptr %3, align 8, !tbaa !5
  %108 = getelementptr inbounds %struct.dpl, ptr %107, i32 0, i32 4
  %109 = load ptr, ptr %3, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.dpl, ptr %109, i32 0, i32 1
  %111 = load i64, ptr %110, align 8, !tbaa !23
  %112 = add i64 %111, 1
  %113 = getelementptr inbounds [18 x %struct.dp], ptr %108, i64 0, i64 %112
  %114 = getelementptr inbounds %struct.dp, ptr %113, i32 0, i32 1
  %115 = load i32, ptr %114, align 8, !tbaa !21
  %116 = icmp eq i32 %115, -1
  br label %117

117:                                              ; preds = %106, %99
  %118 = phi i1 [ false, %99 ], [ %116, %106 ]
  %119 = xor i1 %118, true
  %120 = xor i1 %119, true
  %121 = xor i1 %120, true
  %122 = zext i1 %121 to i32
  %123 = sext i32 %122 to i64
  %124 = call i64 @llvm.expect.i64(i64 %123, i64 0)
  %125 = icmp ne i64 %124, 0
  br i1 %125, label %126, label %127

126:                                              ; preds = %117
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.3, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 85) #6
  unreachable

127:                                              ; preds = %117
  br label %128

128:                                              ; preds = %127
  br label %129

129:                                              ; preds = %128
  br label %130

130:                                              ; preds = %129, %87
  br label %131

131:                                              ; preds = %130
  br label %132

132:                                              ; preds = %131
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #7
  %133 = load ptr, ptr %3, align 8, !tbaa !5
  %134 = getelementptr inbounds %struct.dpl, ptr %133, i32 0, i32 1
  %135 = load i64, ptr %134, align 8, !tbaa !23
  %136 = load ptr, ptr %3, align 8, !tbaa !5
  %137 = getelementptr inbounds %struct.dpl, ptr %136, i32 0, i32 0
  %138 = load i64, ptr %137, align 8, !tbaa !25
  %139 = sub i64 %135, %138
  store i64 %139, ptr %4, align 8, !tbaa !26
  %140 = load i64, ptr %4, align 8, !tbaa !26
  %141 = icmp ult i64 %140, 142
  %142 = xor i1 %141, true
  %143 = xor i1 %142, true
  %144 = zext i1 %143 to i32
  %145 = sext i32 %144 to i64
  %146 = call i64 @llvm.expect.i64(i64 %145, i64 1)
  %147 = icmp ne i64 %146, 0
  br i1 %147, label %164, label %148

148:                                              ; preds = %132
  %149 = load ptr, ptr %3, align 8, !tbaa !5
  %150 = getelementptr inbounds %struct.dpl, ptr %149, i32 0, i32 4
  %151 = getelementptr inbounds [18 x %struct.dp], ptr %150, i64 0, i64 0
  %152 = getelementptr inbounds %struct.dp, ptr %151, i64 1
  %153 = load ptr, ptr %3, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct.dpl, ptr %153, i32 0, i32 1
  %155 = load i64, ptr %154, align 8, !tbaa !23
  %156 = call zeroext i1 @dp_radixsort(ptr noundef %152, i64 noundef %155) #8
  %157 = xor i1 %156, true
  %158 = xor i1 %157, true
  %159 = xor i1 %158, true
  %160 = zext i1 %159 to i32
  %161 = sext i32 %160 to i64
  %162 = call i64 @llvm.expect.i64(i64 %161, i64 0)
  %163 = icmp ne i64 %162, 0
  br i1 %163, label %164, label %496

164:                                              ; preds = %148, %132
  %165 = load ptr, ptr %3, align 8, !tbaa !5
  %166 = getelementptr inbounds %struct.dpl, ptr %165, i32 0, i32 0
  %167 = load i64, ptr %166, align 8, !tbaa !25
  %168 = load i64, ptr %4, align 8, !tbaa !26
  %169 = udiv i64 %168, 4
  %170 = add i64 %169, 4
  %171 = icmp ugt i64 %167, %170
  br i1 %171, label %172, label %436

172:                                              ; preds = %164
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #7
  %173 = load ptr, ptr %3, align 8, !tbaa !5
  %174 = getelementptr inbounds %struct.dpl, ptr %173, i32 0, i32 4
  %175 = getelementptr inbounds [18 x %struct.dp], ptr %174, i64 0, i64 0
  %176 = getelementptr inbounds %struct.dp, ptr %175, i64 1
  store ptr %176, ptr %5, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #7
  %177 = load ptr, ptr %5, align 8, !tbaa !5
  %178 = load ptr, ptr %3, align 8, !tbaa !5
  %179 = getelementptr inbounds %struct.dpl, ptr %178, i32 0, i32 0
  %180 = load i64, ptr %179, align 8, !tbaa !25
  %181 = getelementptr inbounds %struct.dp, ptr %177, i64 %180
  store ptr %181, ptr %6, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #7
  %182 = load ptr, ptr %3, align 8, !tbaa !5
  %183 = getelementptr inbounds %struct.dpl, ptr %182, i32 0, i32 4
  %184 = getelementptr inbounds [18 x %struct.dp], ptr %183, i64 0, i64 0
  %185 = load ptr, ptr %3, align 8, !tbaa !5
  %186 = getelementptr inbounds %struct.dpl, ptr %185, i32 0, i32 1
  %187 = load i64, ptr %186, align 8, !tbaa !23
  %188 = load ptr, ptr %3, align 8, !tbaa !5
  %189 = getelementptr inbounds %struct.dpl, ptr %188, i32 0, i32 1
  %190 = load i64, ptr %189, align 8, !tbaa !23
  %191 = add i64 %187, %190
  %192 = add i64 %191, 1
  %193 = getelementptr inbounds %struct.dp, ptr %184, i64 %192
  store ptr %193, ptr %7, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #7
  %194 = load ptr, ptr %7, align 8, !tbaa !5
  %195 = load i64, ptr %4, align 8, !tbaa !26
  %196 = sub i64 0, %195
  %197 = getelementptr inbounds %struct.dp, ptr %194, i64 %196
  store ptr %197, ptr %8, align 8, !tbaa !5
  br label %198

198:                                              ; preds = %172
  %199 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %200 = zext i8 %199 to i32
  %201 = and i32 %200, 1
  %202 = icmp ne i32 %201, 0
  %203 = xor i1 %202, true
  %204 = xor i1 %203, true
  %205 = zext i1 %204 to i32
  %206 = sext i32 %205 to i64
  %207 = call i64 @llvm.expect.i64(i64 %206, i64 1)
  %208 = icmp ne i64 %207, 0
  br i1 %208, label %209, label %232

209:                                              ; preds = %198
  br label %210

210:                                              ; preds = %209
  %211 = load ptr, ptr %3, align 8, !tbaa !5
  %212 = getelementptr inbounds %struct.dpl, ptr %211, i32 0, i32 4
  %213 = getelementptr inbounds [18 x %struct.dp], ptr %212, i64 0, i64 0
  %214 = load ptr, ptr %3, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.dpl, ptr %214, i32 0, i32 1
  %216 = load i64, ptr %215, align 8, !tbaa !23
  %217 = getelementptr inbounds %struct.dp, ptr %213, i64 %216
  %218 = getelementptr inbounds %struct.dp, ptr %217, i64 1
  %219 = load ptr, ptr %8, align 8, !tbaa !5
  %220 = icmp ult ptr %218, %219
  %221 = xor i1 %220, true
  %222 = xor i1 %221, true
  %223 = xor i1 %222, true
  %224 = zext i1 %223 to i32
  %225 = sext i32 %224 to i64
  %226 = call i64 @llvm.expect.i64(i64 %225, i64 0)
  %227 = icmp ne i64 %226, 0
  br i1 %227, label %228, label %229

228:                                              ; preds = %210
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.4, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 95) #6
  unreachable

229:                                              ; preds = %210
  br label %230

230:                                              ; preds = %229
  br label %231

231:                                              ; preds = %230
  br label %232

232:                                              ; preds = %231, %198
  br label %233

233:                                              ; preds = %232
  br label %234

234:                                              ; preds = %233
  %235 = load ptr, ptr %8, align 8, !tbaa !5
  %236 = load ptr, ptr %6, align 8, !tbaa !5
  %237 = load i64, ptr %4, align 8, !tbaa !26
  %238 = mul i64 %237, 16
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %235, ptr align 8 %236, i64 %238, i1 false)
  %239 = load ptr, ptr %8, align 8, !tbaa !5
  %240 = load ptr, ptr %8, align 8, !tbaa !5
  %241 = load i64, ptr %4, align 8, !tbaa !26
  %242 = getelementptr inbounds %struct.dp, ptr %240, i64 %241
  call void @dp_sort(ptr noundef %239, ptr noundef %242) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #7
  %243 = load ptr, ptr %3, align 8, !tbaa !5
  %244 = getelementptr inbounds %struct.dpl, ptr %243, i32 0, i32 4
  %245 = getelementptr inbounds [18 x %struct.dp], ptr %244, i64 0, i64 0
  %246 = load ptr, ptr %3, align 8, !tbaa !5
  %247 = getelementptr inbounds %struct.dpl, ptr %246, i32 0, i32 1
  %248 = load i64, ptr %247, align 8, !tbaa !23
  %249 = getelementptr inbounds %struct.dp, ptr %245, i64 %248
  store ptr %249, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #7
  %250 = load ptr, ptr %3, align 8, !tbaa !5
  %251 = getelementptr inbounds %struct.dpl, ptr %250, i32 0, i32 4
  %252 = getelementptr inbounds [18 x %struct.dp], ptr %251, i64 0, i64 0
  %253 = load ptr, ptr %3, align 8, !tbaa !5
  %254 = getelementptr inbounds %struct.dpl, ptr %253, i32 0, i32 0
  %255 = load i64, ptr %254, align 8, !tbaa !25
  %256 = getelementptr inbounds %struct.dp, ptr %252, i64 %255
  store ptr %256, ptr %10, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #7
  %257 = load ptr, ptr %7, align 8, !tbaa !5
  %258 = getelementptr inbounds %struct.dp, ptr %257, i64 -1
  store ptr %258, ptr %11, align 8, !tbaa !5
  br label %259

259:                                              ; preds = %282, %234
  call void @llvm.lifetime.start.p0(i64 1, ptr %12) #7
  %260 = load ptr, ptr %10, align 8, !tbaa !5
  %261 = getelementptr inbounds %struct.dp, ptr %260, i32 0, i32 1
  %262 = load i32, ptr %261, align 8, !tbaa !21
  %263 = load ptr, ptr %11, align 8, !tbaa !5
  %264 = getelementptr inbounds %struct.dp, ptr %263, i32 0, i32 1
  %265 = load i32, ptr %264, align 8, !tbaa !21
  %266 = icmp ugt i32 %262, %265
  %267 = zext i1 %266 to i32
  %268 = sext i32 %267 to i64
  %269 = call i64 @llvm.expect.with.probability.i64(i64 %268, i64 0, double 5.000000e-01)
  %270 = icmp ne i64 %269, 0
  %271 = zext i1 %270 to i8
  store i8 %271, ptr %12, align 1, !tbaa !27
  %272 = load ptr, ptr %9, align 8, !tbaa !5
  %273 = load i8, ptr %12, align 1, !tbaa !27, !range !28, !noundef !29
  %274 = trunc i8 %273 to i1
  br i1 %274, label %275, label %278

275:                                              ; preds = %259
  %276 = load ptr, ptr %10, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.dp, ptr %276, i32 -1
  store ptr %277, ptr %10, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %272, ptr align 8 %276, i64 16, i1 false), !tbaa.struct !30
  br label %281

278:                                              ; preds = %259
  %279 = load ptr, ptr %11, align 8, !tbaa !5
  %280 = getelementptr inbounds %struct.dp, ptr %279, i32 -1
  store ptr %280, ptr %11, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %272, ptr align 8 %279, i64 16, i1 false), !tbaa.struct !30
  br label %281

281:                                              ; preds = %278, %275
  call void @llvm.lifetime.end.p0(i64 1, ptr %12) #7
  br label %282

282:                                              ; preds = %281
  %283 = load ptr, ptr %9, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.dp, ptr %283, i32 -1
  store ptr %284, ptr %9, align 8, !tbaa !5
  %285 = load ptr, ptr %10, align 8, !tbaa !5
  %286 = icmp ugt ptr %284, %285
  %287 = xor i1 %286, true
  %288 = xor i1 %287, true
  %289 = zext i1 %288 to i32
  %290 = sext i32 %289 to i64
  %291 = call i64 @llvm.expect.i64(i64 %290, i64 1)
  %292 = icmp ne i64 %291, 0
  br i1 %292, label %259, label %293, !llvm.loop !32

293:                                              ; preds = %282
  br label %294

294:                                              ; preds = %293
  %295 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %296 = zext i8 %295 to i32
  %297 = and i32 %296, 1
  %298 = icmp ne i32 %297, 0
  %299 = xor i1 %298, true
  %300 = xor i1 %299, true
  %301 = zext i1 %300 to i32
  %302 = sext i32 %301 to i64
  %303 = call i64 @llvm.expect.i64(i64 %302, i64 1)
  %304 = icmp ne i64 %303, 0
  br i1 %304, label %305, label %322

305:                                              ; preds = %294
  br label %306

306:                                              ; preds = %305
  %307 = load ptr, ptr %11, align 8, !tbaa !5
  %308 = load ptr, ptr %8, align 8, !tbaa !5
  %309 = getelementptr inbounds %struct.dp, ptr %308, i64 -1
  %310 = icmp eq ptr %307, %309
  %311 = xor i1 %310, true
  %312 = xor i1 %311, true
  %313 = xor i1 %312, true
  %314 = zext i1 %313 to i32
  %315 = sext i32 %314 to i64
  %316 = call i64 @llvm.expect.i64(i64 %315, i64 0)
  %317 = icmp ne i64 %316, 0
  br i1 %317, label %318, label %319

318:                                              ; preds = %306
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.5, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 113) #6
  unreachable

319:                                              ; preds = %306
  br label %320

320:                                              ; preds = %319
  br label %321

321:                                              ; preds = %320
  br label %322

322:                                              ; preds = %321, %294
  br label %323

323:                                              ; preds = %322
  br label %324

324:                                              ; preds = %323
  br label %325

325:                                              ; preds = %324
  %326 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %327 = zext i8 %326 to i32
  %328 = and i32 %327, 1
  %329 = icmp ne i32 %328, 0
  %330 = xor i1 %329, true
  %331 = xor i1 %330, true
  %332 = zext i1 %331 to i32
  %333 = sext i32 %332 to i64
  %334 = call i64 @llvm.expect.i64(i64 %333, i64 1)
  %335 = icmp ne i64 %334, 0
  br i1 %335, label %336, label %368

336:                                              ; preds = %325
  br label %337

337:                                              ; preds = %336
  %338 = load ptr, ptr %3, align 8, !tbaa !5
  %339 = getelementptr inbounds %struct.dpl, ptr %338, i32 0, i32 4
  %340 = getelementptr inbounds [18 x %struct.dp], ptr %339, i64 0, i64 0
  %341 = getelementptr inbounds %struct.dp, ptr %340, i32 0, i32 1
  %342 = load i32, ptr %341, align 8, !tbaa !21
  %343 = icmp eq i32 %342, 0
  br i1 %343, label %344, label %355

344:                                              ; preds = %337
  %345 = load ptr, ptr %3, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.dpl, ptr %345, i32 0, i32 4
  %347 = load ptr, ptr %3, align 8, !tbaa !5
  %348 = getelementptr inbounds %struct.dpl, ptr %347, i32 0, i32 1
  %349 = load i64, ptr %348, align 8, !tbaa !23
  %350 = add i64 %349, 1
  %351 = getelementptr inbounds [18 x %struct.dp], ptr %346, i64 0, i64 %350
  %352 = getelementptr inbounds %struct.dp, ptr %351, i32 0, i32 1
  %353 = load i32, ptr %352, align 8, !tbaa !21
  %354 = icmp eq i32 %353, -1
  br label %355

355:                                              ; preds = %344, %337
  %356 = phi i1 [ false, %337 ], [ %354, %344 ]
  %357 = xor i1 %356, true
  %358 = xor i1 %357, true
  %359 = xor i1 %358, true
  %360 = zext i1 %359 to i32
  %361 = sext i32 %360 to i64
  %362 = call i64 @llvm.expect.i64(i64 %361, i64 0)
  %363 = icmp ne i64 %362, 0
  br i1 %363, label %364, label %365

364:                                              ; preds = %355
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.3, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 114) #6
  unreachable

365:                                              ; preds = %355
  br label %366

366:                                              ; preds = %365
  br label %367

367:                                              ; preds = %366
  br label %368

368:                                              ; preds = %367, %325
  br label %369

369:                                              ; preds = %368
  br label %370

370:                                              ; preds = %369
  %371 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %372 = zext i8 %371 to i32
  %373 = and i32 %372, 1
  %374 = icmp ne i32 %373, 0
  %375 = xor i1 %374, true
  %376 = xor i1 %375, true
  %377 = zext i1 %376 to i32
  %378 = sext i32 %377 to i64
  %379 = call i64 @llvm.expect.i64(i64 %378, i64 1)
  %380 = icmp ne i64 %379, 0
  br i1 %380, label %381, label %435

381:                                              ; preds = %370
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #7
  store i64 0, ptr %13, align 8, !tbaa !26
  br label %382

382:                                              ; preds = %431, %381
  %383 = load i64, ptr %13, align 8, !tbaa !26
  %384 = load ptr, ptr %3, align 8, !tbaa !5
  %385 = getelementptr inbounds %struct.dpl, ptr %384, i32 0, i32 1
  %386 = load i64, ptr %385, align 8, !tbaa !23
  %387 = icmp ule i64 %383, %386
  br i1 %387, label %389, label %388

388:                                              ; preds = %382
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #7
  br label %434

389:                                              ; preds = %382
  br label %390

390:                                              ; preds = %389
  %391 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %392 = zext i8 %391 to i32
  %393 = and i32 %392, 1
  %394 = icmp ne i32 %393, 0
  %395 = xor i1 %394, true
  %396 = xor i1 %395, true
  %397 = zext i1 %396 to i32
  %398 = sext i32 %397 to i64
  %399 = call i64 @llvm.expect.i64(i64 %398, i64 1)
  %400 = icmp ne i64 %399, 0
  br i1 %400, label %401, label %428

401:                                              ; preds = %390
  br label %402

402:                                              ; preds = %401
  %403 = load ptr, ptr %3, align 8, !tbaa !5
  %404 = getelementptr inbounds %struct.dpl, ptr %403, i32 0, i32 4
  %405 = load i64, ptr %13, align 8, !tbaa !26
  %406 = getelementptr inbounds [18 x %struct.dp], ptr %404, i64 0, i64 %405
  %407 = getelementptr inbounds %struct.dp, ptr %406, i32 0, i32 1
  %408 = load i32, ptr %407, align 8, !tbaa !21
  %409 = load ptr, ptr %3, align 8, !tbaa !5
  %410 = getelementptr inbounds %struct.dpl, ptr %409, i32 0, i32 4
  %411 = load i64, ptr %13, align 8, !tbaa !26
  %412 = add i64 %411, 1
  %413 = getelementptr inbounds [18 x %struct.dp], ptr %410, i64 0, i64 %412
  %414 = getelementptr inbounds %struct.dp, ptr %413, i32 0, i32 1
  %415 = load i32, ptr %414, align 8, !tbaa !21
  %416 = icmp ult i32 %408, %415
  %417 = xor i1 %416, true
  %418 = xor i1 %417, true
  %419 = xor i1 %418, true
  %420 = zext i1 %419 to i32
  %421 = sext i32 %420 to i64
  %422 = call i64 @llvm.expect.i64(i64 %421, i64 0)
  %423 = icmp ne i64 %422, 0
  br i1 %423, label %424, label %425

424:                                              ; preds = %402
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.6, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 117) #6
  unreachable

425:                                              ; preds = %402
  br label %426

426:                                              ; preds = %425
  br label %427

427:                                              ; preds = %426
  br label %428

428:                                              ; preds = %427, %390
  br label %429

429:                                              ; preds = %428
  br label %430

430:                                              ; preds = %429
  br label %431

431:                                              ; preds = %430
  %432 = load i64, ptr %13, align 8, !tbaa !26
  %433 = add i64 %432, 1
  store i64 %433, ptr %13, align 8, !tbaa !26
  br label %382, !llvm.loop !34

434:                                              ; preds = %388
  br label %435

435:                                              ; preds = %434, %370
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #7
  br label %495

436:                                              ; preds = %164
  %437 = load ptr, ptr %3, align 8, !tbaa !5
  %438 = getelementptr inbounds %struct.dpl, ptr %437, i32 0, i32 4
  %439 = getelementptr inbounds [18 x %struct.dp], ptr %438, i64 0, i64 0
  %440 = getelementptr inbounds %struct.dp, ptr %439, i64 1
  %441 = load ptr, ptr %3, align 8, !tbaa !5
  %442 = getelementptr inbounds %struct.dpl, ptr %441, i32 0, i32 4
  %443 = getelementptr inbounds [18 x %struct.dp], ptr %442, i64 0, i64 0
  %444 = load ptr, ptr %3, align 8, !tbaa !5
  %445 = getelementptr inbounds %struct.dpl, ptr %444, i32 0, i32 1
  %446 = load i64, ptr %445, align 8, !tbaa !23
  %447 = getelementptr inbounds %struct.dp, ptr %443, i64 %446
  %448 = getelementptr inbounds %struct.dp, ptr %447, i64 1
  call void @dp_sort(ptr noundef %440, ptr noundef %448) #8
  br label %449

449:                                              ; preds = %436
  %450 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %451 = zext i8 %450 to i32
  %452 = and i32 %451, 1
  %453 = icmp ne i32 %452, 0
  %454 = xor i1 %453, true
  %455 = xor i1 %454, true
  %456 = zext i1 %455 to i32
  %457 = sext i32 %456 to i64
  %458 = call i64 @llvm.expect.i64(i64 %457, i64 1)
  %459 = icmp ne i64 %458, 0
  br i1 %459, label %460, label %492

460:                                              ; preds = %449
  br label %461

461:                                              ; preds = %460
  %462 = load ptr, ptr %3, align 8, !tbaa !5
  %463 = getelementptr inbounds %struct.dpl, ptr %462, i32 0, i32 4
  %464 = getelementptr inbounds [18 x %struct.dp], ptr %463, i64 0, i64 0
  %465 = getelementptr inbounds %struct.dp, ptr %464, i32 0, i32 1
  %466 = load i32, ptr %465, align 8, !tbaa !21
  %467 = icmp eq i32 %466, 0
  br i1 %467, label %468, label %479

468:                                              ; preds = %461
  %469 = load ptr, ptr %3, align 8, !tbaa !5
  %470 = getelementptr inbounds %struct.dpl, ptr %469, i32 0, i32 4
  %471 = load ptr, ptr %3, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.dpl, ptr %471, i32 0, i32 1
  %473 = load i64, ptr %472, align 8, !tbaa !23
  %474 = add i64 %473, 1
  %475 = getelementptr inbounds [18 x %struct.dp], ptr %470, i64 0, i64 %474
  %476 = getelementptr inbounds %struct.dp, ptr %475, i32 0, i32 1
  %477 = load i32, ptr %476, align 8, !tbaa !21
  %478 = icmp eq i32 %477, -1
  br label %479

479:                                              ; preds = %468, %461
  %480 = phi i1 [ false, %461 ], [ %478, %468 ]
  %481 = xor i1 %480, true
  %482 = xor i1 %481, true
  %483 = xor i1 %482, true
  %484 = zext i1 %483 to i32
  %485 = sext i32 %484 to i64
  %486 = call i64 @llvm.expect.i64(i64 %485, i64 0)
  %487 = icmp ne i64 %486, 0
  br i1 %487, label %488, label %489

488:                                              ; preds = %479
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.3, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 120) #6
  unreachable

489:                                              ; preds = %479
  br label %490

490:                                              ; preds = %489
  br label %491

491:                                              ; preds = %490
  br label %492

492:                                              ; preds = %491, %449
  br label %493

493:                                              ; preds = %492
  br label %494

494:                                              ; preds = %493
  br label %495

495:                                              ; preds = %494, %435
  br label %543

496:                                              ; preds = %148
  br label %497

497:                                              ; preds = %496
  %498 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !9
  %499 = zext i8 %498 to i32
  %500 = and i32 %499, 1
  %501 = icmp ne i32 %500, 0
  %502 = xor i1 %501, true
  %503 = xor i1 %502, true
  %504 = zext i1 %503 to i32
  %505 = sext i32 %504 to i64
  %506 = call i64 @llvm.expect.i64(i64 %505, i64 1)
  %507 = icmp ne i64 %506, 0
  br i1 %507, label %508, label %540

508:                                              ; preds = %497
  br label %509

509:                                              ; preds = %508
  %510 = load ptr, ptr %3, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.dpl, ptr %510, i32 0, i32 4
  %512 = getelementptr inbounds [18 x %struct.dp], ptr %511, i64 0, i64 0
  %513 = getelementptr inbounds %struct.dp, ptr %512, i32 0, i32 1
  %514 = load i32, ptr %513, align 8, !tbaa !21
  %515 = icmp eq i32 %514, 0
  br i1 %515, label %516, label %527

516:                                              ; preds = %509
  %517 = load ptr, ptr %3, align 8, !tbaa !5
  %518 = getelementptr inbounds %struct.dpl, ptr %517, i32 0, i32 4
  %519 = load ptr, ptr %3, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.dpl, ptr %519, i32 0, i32 1
  %521 = load i64, ptr %520, align 8, !tbaa !23
  %522 = add i64 %521, 1
  %523 = getelementptr inbounds [18 x %struct.dp], ptr %518, i64 0, i64 %522
  %524 = getelementptr inbounds %struct.dp, ptr %523, i32 0, i32 1
  %525 = load i32, ptr %524, align 8, !tbaa !21
  %526 = icmp eq i32 %525, -1
  br label %527

527:                                              ; preds = %516, %509
  %528 = phi i1 [ false, %509 ], [ %526, %516 ]
  %529 = xor i1 %528, true
  %530 = xor i1 %529, true
  %531 = xor i1 %530, true
  %532 = zext i1 %531 to i32
  %533 = sext i32 %532 to i64
  %534 = call i64 @llvm.expect.i64(i64 %533, i64 0)
  %535 = icmp ne i64 %534, 0
  br i1 %535, label %536, label %537

536:                                              ; preds = %527
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.3, ptr noundef @__func__.dpl_sort_slowpath, i32 noundef 123) #6
  unreachable

537:                                              ; preds = %527
  br label %538

538:                                              ; preds = %537
  br label %539

539:                                              ; preds = %538
  br label %540

540:                                              ; preds = %539, %497
  br label %541

541:                                              ; preds = %540
  br label %542

542:                                              ; preds = %541
  br label %543

543:                                              ; preds = %542, %495
  %544 = load ptr, ptr %3, align 8, !tbaa !5
  %545 = getelementptr inbounds %struct.dpl, ptr %544, i32 0, i32 1
  %546 = load i64, ptr %545, align 8, !tbaa !23
  %547 = load ptr, ptr %3, align 8, !tbaa !5
  %548 = getelementptr inbounds %struct.dpl, ptr %547, i32 0, i32 0
  store i64 %546, ptr %548, align 8, !tbaa !25
  %549 = load ptr, ptr %3, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %3) #7
  ret ptr %549
}

; Function Attrs: hot nounwind uwtable
declare hidden zeroext i1 @dp_radixsort(ptr noundef, i64 noundef) #4

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #5

; Function Attrs: hot nounwind uwtable
declare hidden void @dp_sort(ptr noalias noundef, ptr noalias noundef) #4

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare i64 @llvm.expect.with.probability.i64(i64, i64, double immarg) #0

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(none) }
attributes #1 = { noreturn "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { hot noinline nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { hot nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #6 = { noreturn }
attributes #7 = { nounwind }
attributes #8 = { hot }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !7, i64 25}
!10 = !{!"libmdbx_globals", !7, i64 0, !11, i64 16, !11, i64 20, !7, i64 24, !7, i64 25, !7, i64 26, !12, i64 27, !11, i64 28, !7, i64 32, !7, i64 40, !13, i64 80, !6, i64 88}
!11 = !{!"int", !7, i64 0}
!12 = !{!"_Bool", !7, i64 0}
!13 = !{!"long", !7, i64 0}
!14 = !{!15, !11, i64 4}
!15 = !{!"MDBX_txn", !11, i64 0, !11, i64 4, !13, i64 8, !13, i64 16, !6, i64 24, !6, i64 32, !16, i64 40, !13, i64 64, !13, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112, !6, i64 120, !18, i64 128, !6, i64 160, !7, i64 168}
!16 = !{!"geo", !17, i64 0, !17, i64 2, !11, i64 4, !11, i64 8, !7, i64 12, !7, i64 16}
!17 = !{!"short", !7, i64 0}
!18 = !{!"MDBX_canary", !13, i64 0, !13, i64 8, !13, i64 16, !13, i64 24}
!19 = !{!15, !6, i64 80}
!20 = !{!7, !7, i64 0}
!21 = !{!22, !11, i64 8}
!22 = !{!"dp", !6, i64 0, !11, i64 8, !11, i64 12}
!23 = !{!24, !13, i64 8}
!24 = !{!"dpl", !13, i64 0, !13, i64 8, !13, i64 16, !13, i64 24, !7, i64 32}
!25 = !{!24, !13, i64 0}
!26 = !{!13, !13, i64 0}
!27 = !{!12, !12, i64 0}
!28 = !{i8 0, i8 2}
!29 = !{}
!30 = !{i64 0, i64 8, !5, i64 8, i64 4, !31, i64 12, i64 4, !31}
!31 = !{!11, !11, i64 0}
!32 = distinct !{!32, !33}
!33 = !{!"llvm.loop.mustprogress"}
!34 = distinct !{!34, !33}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.libmdbx_globals = type { %union.bin128, i32, i32, i8, i8, i8, i8, i32, %union.logger_union, %union.pthread_mutex_t, i64, ptr }
%union.bin128 = type { %struct.anon.6 }
%struct.anon.6 = type { i64, i64 }
%union.logger_union = type { ptr }
%union.pthread_mutex_t = type { %struct.__pthread_mutex_s }
%struct.__pthread_mutex_s = type { i32, i32, i32, i32, i32, i16, i16, %struct.__pthread_internal_list }
%struct.__pthread_internal_list = type { ptr, ptr }
%struct.dp = type { ptr, i32, i32 }

@globals = external local_unnamed_addr global %struct.libmdbx_globals, align 8
@.str = external hidden unnamed_addr constant [36 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [39 x i8], align 1
@__func__.dpl_sort_slowpath = external hidden unnamed_addr constant [18 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [73 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [33 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [42 x i8], align 1

; Function Attrs: noreturn
declare void @mdbx_assert_fail(ptr noundef, ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #0

; Function Attrs: hot noinline nounwind uwtable
define dso_local noundef ptr @dpl_sort_slowpath(ptr nocapture noundef readonly %0) local_unnamed_addr #1 {
  %2 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !5
  %3 = and i8 %2, 1
  %.not = icmp eq i8 %3, 0
  br i1 %.not, label %.thread97, label %6, !prof !13

.thread97:                                        ; preds = %1
  %4 = getelementptr inbounds i8, ptr %0, i64 496
  %5 = load ptr, ptr %4, align 8, !tbaa !14
  %.phi.trans.insert = getelementptr inbounds i8, ptr %5, i64 8
  %.pre = load i64, ptr %.phi.trans.insert, align 8, !tbaa !15
  br label %32

6:                                                ; preds = %1
  %7 = getelementptr inbounds i8, ptr %0, i64 4
  %8 = load i32, ptr %7, align 4, !tbaa !17
  %9 = and i32 %8, 131072
  %.not74 = icmp eq i32 %9, 0
  br i1 %.not74, label %13, label %10, !prof !22

10:                                               ; preds = %6
  %11 = getelementptr inbounds i8, ptr %0, i64 80
  %12 = load ptr, ptr %11, align 8, !tbaa !23
  tail call void @mdbx_assert_fail(ptr noundef %12, ptr noundef nonnull @.str, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 81) #4
  unreachable

13:                                               ; preds = %6
  %14 = and i32 %8, 524288
  %.not76 = icmp eq i32 %14, 0
  br i1 %.not76, label %18, label %15, !prof !22

15:                                               ; preds = %13
  %16 = getelementptr inbounds i8, ptr %0, i64 80
  %17 = load ptr, ptr %16, align 8, !tbaa !23
  tail call void @mdbx_assert_fail(ptr noundef %17, ptr noundef nonnull @.str.1, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 82) #4
  unreachable

18:                                               ; preds = %13
  %19 = getelementptr inbounds i8, ptr %0, i64 496
  %20 = load ptr, ptr %19, align 8, !tbaa !14
  %21 = getelementptr inbounds i8, ptr %20, i64 40
  %22 = load i32, ptr %21, align 8, !tbaa !24
  %23 = icmp eq i32 %22, 0
  br i1 %23, label %24, label %.critedge, !prof !22

24:                                               ; preds = %18
  %25 = getelementptr inbounds i8, ptr %20, i64 32
  %26 = getelementptr inbounds i8, ptr %20, i64 8
  %27 = load i64, ptr %26, align 8, !tbaa !15
  %28 = add i64 %27, 1
  %29 = getelementptr inbounds [18 x %struct.dp], ptr %25, i64 0, i64 %28, i32 1
  %30 = load i32, ptr %29, align 8, !tbaa !24
  %31 = icmp eq i32 %30, -1
  br i1 %31, label %32, label %.critedge, !prof !22

.critedge:                                        ; preds = %18, %24
  tail call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 85) #4
  unreachable

32:                                               ; preds = %.thread97, %24
  %33 = phi i64 [ %.pre, %.thread97 ], [ %27, %24 ]
  %34 = phi ptr [ %5, %.thread97 ], [ %20, %24 ]
  %35 = getelementptr inbounds i8, ptr %34, i64 8
  %36 = load i64, ptr %34, align 8, !tbaa !26
  %37 = sub i64 %33, %36
  %38 = icmp ult i64 %37, 142
  br i1 %38, label %43, label %39, !prof !22

39:                                               ; preds = %32
  %40 = getelementptr inbounds i8, ptr %34, i64 32
  %41 = getelementptr inbounds i8, ptr %34, i64 48
  %42 = tail call zeroext i1 @dp_radixsort(ptr noundef nonnull %41, i64 noundef %33) #5
  br i1 %42, label %115, label %._crit_edge, !prof !22

._crit_edge:                                      ; preds = %39
  %.pre103 = load i64, ptr %34, align 8, !tbaa !26
  br label %43

43:                                               ; preds = %._crit_edge, %32
  %44 = phi i64 [ %.pre103, %._crit_edge ], [ %36, %32 ]
  %45 = lshr i64 %37, 2
  %46 = add nuw nsw i64 %45, 4
  %47 = icmp ugt i64 %44, %46
  %48 = getelementptr inbounds i8, ptr %34, i64 32
  br i1 %47, label %49, label %99

49:                                               ; preds = %43
  %50 = load i64, ptr %35, align 8, !tbaa !15
  %51 = shl i64 %50, 1
  %52 = or disjoint i64 %51, 1
  %53 = getelementptr inbounds %struct.dp, ptr %48, i64 %52
  %54 = sub i64 0, %37
  %55 = getelementptr inbounds %struct.dp, ptr %53, i64 %54
  %56 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !5
  %57 = and i8 %56, 1
  %.not80 = icmp eq i8 %57, 0
  %58 = getelementptr inbounds %struct.dp, ptr %48, i64 %50
  %59 = getelementptr inbounds i8, ptr %58, i64 16
  %.not81 = icmp ult ptr %59, %55
  %or.cond = select i1 %.not80, i1 true, i1 %.not81
  br i1 %or.cond, label %61, label %60, !prof !27

60:                                               ; preds = %49
  tail call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.4, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 95) #4
  unreachable

61:                                               ; preds = %49
  %62 = getelementptr inbounds i8, ptr %34, i64 48
  %63 = getelementptr inbounds %struct.dp, ptr %62, i64 %44
  %64 = shl i64 %37, 4
  tail call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %55, ptr nonnull align 8 %63, i64 %64, i1 false)
  tail call void @dp_sort(ptr noundef nonnull %55, ptr noundef nonnull %53) #5
  %65 = load i64, ptr %35, align 8, !tbaa !15
  %66 = getelementptr inbounds %struct.dp, ptr %48, i64 %65
  %67 = load i64, ptr %34, align 8, !tbaa !26
  %68 = getelementptr inbounds %struct.dp, ptr %48, i64 %67
  %69 = getelementptr inbounds i8, ptr %53, i64 -16
  br label %70

70:                                               ; preds = %70, %61
  %.070 = phi ptr [ %68, %61 ], [ %.171, %70 ]
  %.069 = phi ptr [ %69, %61 ], [ %.1, %70 ]
  %.068 = phi ptr [ %66, %61 ], [ %76, %70 ]
  %71 = getelementptr inbounds i8, ptr %.070, i64 8
  %72 = load i32, ptr %71, align 8, !tbaa !24
  %73 = getelementptr inbounds i8, ptr %.069, i64 8
  %74 = load i32, ptr %73, align 8, !tbaa !24
  %75 = icmp ugt i32 %72, %74
  %.069.sink = select i1 %75, ptr %.070, ptr %.069
  %.171.idx = select i1 %75, i64 -16, i64 0
  %.171 = getelementptr inbounds i8, ptr %.070, i64 %.171.idx
  %.1.idx = select i1 %75, i64 0, i64 -16
  %.1 = getelementptr inbounds i8, ptr %.069, i64 %.1.idx
  tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %.068, ptr noundef nonnull align 8 dereferenceable(16) %.069.sink, i64 16, i1 false)
  %76 = getelementptr inbounds i8, ptr %.068, i64 -16
  %77 = icmp ugt ptr %76, %.171
  br i1 %77, label %70, label %78, !prof !22, !llvm.loop !28

78:                                               ; preds = %70
  %79 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !5
  %80 = and i8 %79, 1
  %.not82 = icmp eq i8 %80, 0
  %81 = getelementptr inbounds i8, ptr %55, i64 -16
  %.not83 = icmp eq ptr %.1, %81
  %or.cond90 = select i1 %.not82, i1 true, i1 %.not83
  br i1 %or.cond90, label %83, label %82, !prof !27

82:                                               ; preds = %78
  tail call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.5, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 113) #4
  unreachable

83:                                               ; preds = %78
  br i1 %.not82, label %.thread98, label %84, !prof !13

84:                                               ; preds = %83
  %85 = getelementptr inbounds i8, ptr %34, i64 40
  %86 = load i32, ptr %85, align 8, !tbaa !24
  %87 = icmp eq i32 %86, 0
  br i1 %87, label %88, label %.critedge92, !prof !22

88:                                               ; preds = %84
  %89 = load i64, ptr %35, align 8, !tbaa !15
  %90 = add i64 %89, 1
  %91 = getelementptr inbounds [18 x %struct.dp], ptr %48, i64 0, i64 %90, i32 1
  %92 = load i32, ptr %91, align 8, !tbaa !24
  %.not101 = icmp eq i32 %92, -1
  br i1 %.not101, label %.preheader, label %.critedge92, !prof !22

.critedge92:                                      ; preds = %84, %88
  tail call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 114) #4
  unreachable

93:                                               ; preds = %.preheader
  %.not86 = icmp ugt i64 %95, %89
  br i1 %.not86, label %.thread98, label %.preheader, !llvm.loop !30

.preheader:                                       ; preds = %88, %93
  %94 = phi i32 [ %97, %93 ], [ 0, %88 ]
  %.0102 = phi i64 [ %95, %93 ], [ 0, %88 ]
  %95 = add i64 %.0102, 1
  %96 = getelementptr inbounds [18 x %struct.dp], ptr %48, i64 0, i64 %95, i32 1
  %97 = load i32, ptr %96, align 8, !tbaa !24
  %.not88 = icmp ult i32 %94, %97
  br i1 %.not88, label %93, label %98, !prof !22

98:                                               ; preds = %.preheader
  tail call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.6, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 117) #4
  unreachable

99:                                               ; preds = %43
  %100 = getelementptr inbounds i8, ptr %34, i64 48
  %101 = load i64, ptr %35, align 8, !tbaa !15
  %102 = getelementptr inbounds %struct.dp, ptr %48, i64 %101
  %103 = getelementptr inbounds i8, ptr %102, i64 16
  tail call void @dp_sort(ptr noundef nonnull %100, ptr noundef nonnull %103) #5
  %104 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !5
  %105 = and i8 %104, 1
  %.not79 = icmp eq i8 %105, 0
  br i1 %.not79, label %.thread98, label %106, !prof !13

106:                                              ; preds = %99
  %107 = getelementptr inbounds i8, ptr %34, i64 40
  %108 = load i32, ptr %107, align 8, !tbaa !24
  %109 = icmp eq i32 %108, 0
  br i1 %109, label %110, label %.critedge94, !prof !22

110:                                              ; preds = %106
  %111 = load i64, ptr %35, align 8, !tbaa !15
  %112 = add i64 %111, 1
  %113 = getelementptr inbounds [18 x %struct.dp], ptr %48, i64 0, i64 %112, i32 1
  %114 = load i32, ptr %113, align 8, !tbaa !24
  %.not100 = icmp eq i32 %114, -1
  br i1 %.not100, label %.thread98, label %.critedge94, !prof !22

.critedge94:                                      ; preds = %106, %110
  tail call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 120) #4
  unreachable

115:                                              ; preds = %39
  %116 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !5
  %117 = and i8 %116, 1
  %.not78 = icmp eq i8 %117, 0
  br i1 %.not78, label %.thread98, label %118, !prof !13

118:                                              ; preds = %115
  %119 = getelementptr inbounds i8, ptr %34, i64 40
  %120 = load i32, ptr %119, align 8, !tbaa !24
  %121 = icmp eq i32 %120, 0
  br i1 %121, label %122, label %.critedge96, !prof !22

122:                                              ; preds = %118
  %123 = load i64, ptr %35, align 8, !tbaa !15
  %124 = add i64 %123, 1
  %125 = getelementptr inbounds [18 x %struct.dp], ptr %40, i64 0, i64 %124, i32 1
  %126 = load i32, ptr %125, align 8, !tbaa !24
  %.not99 = icmp eq i32 %126, -1
  br i1 %.not99, label %.thread98, label %.critedge96, !prof !22

.critedge96:                                      ; preds = %118, %122
  tail call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.dpl_sort_slowpath, i32 noundef 123) #4
  unreachable

.thread98:                                        ; preds = %93, %83, %115, %122, %110, %99
  %127 = load i64, ptr %35, align 8, !tbaa !15
  store i64 %127, ptr %34, align 8, !tbaa !26
  ret ptr %34
}

; Function Attrs: hot nounwind uwtable
declare hidden zeroext i1 @dp_radixsort(ptr noundef, i64 noundef) local_unnamed_addr #2

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #3

; Function Attrs: hot nounwind uwtable
declare hidden void @dp_sort(ptr noalias noundef, ptr noalias noundef) local_unnamed_addr #2

attributes #0 = { noreturn "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { hot noinline nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { hot nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { noreturn nounwind }
attributes #5 = { hot }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !7, i64 25}
!6 = !{!"libmdbx_globals", !7, i64 0, !9, i64 16, !9, i64 20, !7, i64 24, !7, i64 25, !7, i64 26, !10, i64 27, !9, i64 28, !7, i64 32, !7, i64 40, !11, i64 80, !12, i64 88}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!"int", !7, i64 0}
!10 = !{!"_Bool", !7, i64 0}
!11 = !{!"long", !7, i64 0}
!12 = !{!"any pointer", !7, i64 0}
!13 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!14 = !{!7, !7, i64 0}
!15 = !{!16, !11, i64 8}
!16 = !{!"dpl", !11, i64 0, !11, i64 8, !11, i64 16, !11, i64 24, !7, i64 32}
!17 = !{!18, !9, i64 4}
!18 = !{!"MDBX_txn", !9, i64 0, !9, i64 4, !11, i64 8, !11, i64 16, !12, i64 24, !12, i64 32, !19, i64 40, !11, i64 64, !11, i64 72, !12, i64 80, !12, i64 88, !12, i64 96, !12, i64 104, !12, i64 112, !12, i64 120, !21, i64 128, !12, i64 160, !7, i64 168}
!19 = !{!"geo", !20, i64 0, !20, i64 2, !9, i64 4, !9, i64 8, !7, i64 12, !7, i64 16}
!20 = !{!"short", !7, i64 0}
!21 = !{!"MDBX_canary", !11, i64 0, !11, i64 8, !11, i64 16, !11, i64 24}
!22 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!23 = !{!18, !12, i64 80}
!24 = !{!25, !9, i64 8}
!25 = !{!"dp", !12, i64 0, !9, i64 8, !9, i64 12}
!26 = !{!16, !11, i64 0}
!27 = !{!"branch_weights", i32 4002001, i32 2000}
!28 = distinct !{!28, !29}
!29 = !{!"llvm.loop.mustprogress"}
!30 = distinct !{!30, !29}


; Effective O3 passes: BDCEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LowerExpectIntrinsicPass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass