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

; 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.8 }
%struct.anon.8 = 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.page_get_result = type { ptr, i32 }
%struct.MDBX_cursor = type { i32, %union.anon, i8, i8, ptr, ptr, ptr, ptr, ptr, [32 x ptr], [32 x i16], ptr, ptr }
%union.anon = type { i16 }
%struct.anon = type { i8, i8 }
%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.2 }
%struct.geo = type { i16, i16, i32, i32, %union.anon.0, %union.anon.1 }
%union.anon.0 = type { i32 }
%union.anon.1 = type { i32 }
%struct.MDBX_canary = type { i64, i64, i64, i64 }
%union.anon.2 = type { %struct.anon.4 }
%struct.anon.4 = type { %struct.troika, ptr, %struct.anon.5, i8, i32, i32, i64, ptr, ptr, ptr, i64, %union.anon.6 }
%struct.troika = type { i8, i8, i8, i8, i32, [3 x i64] }
%struct.anon.5 = type { %struct.MDBX_rkl, i64, %struct.MDBX_rkl }
%struct.MDBX_rkl = type { i64, i64, i32, i32, ptr, [12 x i64] }
%union.anon.6 = type { %struct.anon.7 }
%struct.anon.7 = type { i64, ptr }
%struct.page = type <{ i64, i16, i16, %union.anon.18, i32, [0 x i16] }>
%union.anon.18 = type { i32 }
%struct.inner_cursor = type { %struct.MDBX_cursor, %struct.tree }
%struct.tree = type { i16, i16, i32, i32, i32, i32, i32, i64, i64, i64 }

@globals = external global %struct.libmdbx_globals, align 8
@.str.47 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.95 = external hidden unnamed_addr constant [26 x i8], align 1
@__func__.cursor_del = external hidden unnamed_addr constant [11 x i8], align 1
@.str.96 = external hidden unnamed_addr constant [51 x i8], align 1
@.str.97 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.98 = external hidden unnamed_addr constant [78 x i8], align 1
@.str.99 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.100 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.101 = external hidden unnamed_addr constant [111 x i8], align 1
@.str.102 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.103 = external hidden unnamed_addr constant [100 x i8], align 1
@.str.104 = external hidden unnamed_addr constant [67 x i8], align 1

; Function Attrs: cold nounwind optsize uwtable
declare dso_local i32 @cursor_validate(ptr noundef) #0

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

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

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_pointed(ptr noundef) #3

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

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @page_numkeys(ptr noundef) #3

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @inner_pointed(ptr noundef) #3

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_filled(ptr noundef) #3

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

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden ptr @page_node(ptr noundef, i64 noundef) #3

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i8 @node_flags(ptr noalias noundef) #3

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_leaf(ptr noundef) #3

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @cursor_dbi(ptr noundef) #3

; Function Attrs: hot nounwind uwtable
declare dso_local i32 @cursor_touch(ptr noundef, ptr noundef, ptr noundef) #5

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_modifable(ptr noundef, ptr noundef) #3

; 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) #6

; Function Attrs: nounwind uwtable
declare dso_local i32 @cursor_dupsort_setup(ptr noundef, ptr noundef, ptr noundef) #7

declare void @debug_log(i32 noundef, ptr noundef, i32 noundef, ptr noundef, ...) #8

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden ptr @node_data(ptr noalias noundef) #3

; Function Attrs: hot nounwind uwtable
declare dso_local i32 @cursor_sibling_right(ptr noundef) #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @inner_gone(ptr noundef) #9

; Function Attrs: hot nounwind uwtable
declare dso_local i32 @inner_first(ptr noundef, ptr noundef) #5

; Function Attrs: hot nounwind uwtable
define dso_local i32 @cursor_del(ptr noundef %0, i32 noundef %1) #5 {
  %3 = alloca i32, align 4
  %4 = alloca ptr, align 8
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca %struct.page_get_result, align 8
  %14 = alloca i32, align 4
  %15 = alloca i16, align 2
  %16 = alloca ptr, align 8
  %17 = alloca ptr, align 8
  %18 = alloca i64, align 8
  %19 = alloca i64, align 8
  %20 = alloca ptr, align 8
  %21 = alloca ptr, align 8
  store ptr %0, ptr %4, align 8, !tbaa !5
  store i32 %1, ptr %5, align 4, !tbaa !9
  %22 = load ptr, ptr %4, align 8, !tbaa !5
  %23 = call zeroext i1 @is_filled(ptr noundef %22) #10
  %24 = xor i1 %23, true
  %25 = xor i1 %24, true
  %26 = xor i1 %25, true
  %27 = zext i1 %26 to i32
  %28 = sext i32 %27 to i64
  %29 = call i64 @llvm.expect.i64(i64 %28, i64 0)
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %31, label %32

31:                                               ; preds = %2
  store i32 61, ptr %3, align 4
  br label %1346

32:                                               ; preds = %2
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #11
  %33 = load ptr, ptr %4, align 8, !tbaa !5
  %34 = call i32 @cursor_touch(ptr noundef %33, ptr noundef null, ptr noundef null) #12
  store i32 %34, ptr %6, align 4, !tbaa !9
  %35 = load i32, ptr %6, align 4, !tbaa !9
  %36 = icmp ne i32 %35, 0
  %37 = xor i1 %36, true
  %38 = xor i1 %37, true
  %39 = zext i1 %38 to i32
  %40 = sext i32 %39 to i64
  %41 = call i64 @llvm.expect.i64(i64 %40, i64 0)
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %43, label %45

43:                                               ; preds = %32
  %44 = load i32, ptr %6, align 4, !tbaa !9
  store i32 %44, ptr %3, align 4
  store i32 1, ptr %7, align 4
  br label %1345

45:                                               ; preds = %32
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #11
  %46 = load ptr, ptr %4, align 8, !tbaa !5
  %47 = getelementptr inbounds %struct.MDBX_cursor, ptr %46, i32 0, i32 9
  %48 = load ptr, ptr %4, align 8, !tbaa !5
  %49 = getelementptr inbounds %struct.MDBX_cursor, ptr %48, i32 0, i32 1
  %50 = getelementptr inbounds %struct.anon, ptr %49, i32 0, i32 1
  %51 = load i8, ptr %50, align 1, !tbaa !11
  %52 = sext i8 %51 to i64
  %53 = getelementptr inbounds [32 x ptr], ptr %47, i64 0, i64 %52
  %54 = load ptr, ptr %53, align 8, !tbaa !5
  store ptr %54, ptr %8, align 8, !tbaa !5
  br label %55

55:                                               ; preds = %45
  %56 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %57 = zext i8 %56 to i32
  %58 = and i32 %57, 1
  %59 = icmp ne i32 %58, 0
  %60 = xor i1 %59, true
  %61 = xor i1 %60, true
  %62 = zext i1 %61 to i32
  %63 = sext i32 %62 to i64
  %64 = call i64 @llvm.expect.i64(i64 %63, i64 1)
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %66, label %89

66:                                               ; preds = %55
  br label %67

67:                                               ; preds = %66
  %68 = load ptr, ptr %4, align 8, !tbaa !5
  %69 = getelementptr inbounds %struct.MDBX_cursor, ptr %68, i32 0, i32 5
  %70 = load ptr, ptr %69, align 8, !tbaa !16
  %71 = load ptr, ptr %8, align 8, !tbaa !5
  %72 = call zeroext i1 @is_modifable(ptr noundef %70, ptr noundef %71) #10
  %73 = xor i1 %72, true
  %74 = xor i1 %73, true
  %75 = xor i1 %74, true
  %76 = zext i1 %75 to i32
  %77 = sext i32 %76 to i64
  %78 = call i64 @llvm.expect.i64(i64 %77, i64 0)
  %79 = icmp ne i64 %78, 0
  br i1 %79, label %80, label %86

80:                                               ; preds = %67
  %81 = load ptr, ptr %4, align 8, !tbaa !5
  %82 = getelementptr inbounds %struct.MDBX_cursor, ptr %81, i32 0, i32 5
  %83 = load ptr, ptr %82, align 8, !tbaa !16
  %84 = getelementptr inbounds %struct.MDBX_txn, ptr %83, i32 0, i32 9
  %85 = load ptr, ptr %84, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %85, ptr noundef @.str.95, ptr noundef @__func__.cursor_del, i32 noundef 1533) #13
  unreachable

86:                                               ; preds = %67
  br label %87

87:                                               ; preds = %86
  br label %88

88:                                               ; preds = %87
  br label %89

89:                                               ; preds = %88, %55
  br label %90

90:                                               ; preds = %89
  br label %91

91:                                               ; preds = %90
  %92 = load ptr, ptr %4, align 8, !tbaa !5
  %93 = load ptr, ptr %8, align 8, !tbaa !5
  %94 = call zeroext i1 @check_leaf_type(ptr noundef %92, ptr noundef %93) #10
  %95 = xor i1 %94, true
  %96 = xor i1 %95, true
  %97 = xor i1 %96, true
  %98 = zext i1 %97 to i32
  %99 = sext i32 %98 to i64
  %100 = call i64 @llvm.expect.i64(i64 %99, i64 0)
  %101 = icmp ne i64 %100, 0
  br i1 %101, label %102, label %124

102:                                              ; preds = %91
  br label %103

103:                                              ; preds = %102
  %104 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !23
  %105 = zext i8 %104 to i32
  %106 = icmp sle i32 1, %105
  %107 = xor i1 %106, true
  %108 = xor i1 %107, true
  %109 = zext i1 %108 to i32
  %110 = sext i32 %109 to i64
  %111 = call i64 @llvm.expect.i64(i64 %110, i64 0)
  %112 = icmp ne i64 %111, 0
  br i1 %112, label %113, label %121

113:                                              ; preds = %103
  %114 = load ptr, ptr %8, align 8, !tbaa !5
  %115 = getelementptr inbounds %struct.page, ptr %114, i32 0, i32 4
  %116 = load i32, ptr %115, align 1, !tbaa !9
  %117 = load ptr, ptr %8, align 8, !tbaa !5
  %118 = getelementptr inbounds %struct.page, ptr %117, i32 0, i32 2
  %119 = load i16, ptr %118, align 1, !tbaa !24
  %120 = zext i16 %119 to i32
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 1, ptr noundef @__func__.cursor_del, i32 noundef 1535, ptr noundef @.str.96, i32 noundef %116, i32 noundef %120)
  br label %121

121:                                              ; preds = %113, %103
  br label %122

122:                                              ; preds = %121
  br label %123

123:                                              ; preds = %122
  store i32 -30796, ptr %3, align 4
  store i32 1, ptr %7, align 4
  br label %1344

124:                                              ; preds = %91
  %125 = load ptr, ptr %8, align 8, !tbaa !5
  %126 = call zeroext i1 @is_dupfix_leaf(ptr noundef %125) #10
  br i1 %126, label %127, label %128

127:                                              ; preds = %124
  br label %603

128:                                              ; preds = %124
  %129 = load ptr, ptr %8, align 8, !tbaa !5
  %130 = load ptr, ptr %4, align 8, !tbaa !5
  %131 = getelementptr inbounds %struct.MDBX_cursor, ptr %130, i32 0, i32 10
  %132 = load ptr, ptr %4, align 8, !tbaa !5
  %133 = getelementptr inbounds %struct.MDBX_cursor, ptr %132, i32 0, i32 1
  %134 = getelementptr inbounds %struct.anon, ptr %133, i32 0, i32 1
  %135 = load i8, ptr %134, align 1, !tbaa !11
  %136 = sext i8 %135 to i64
  %137 = getelementptr inbounds [32 x i16], ptr %131, i64 0, i64 %136
  %138 = load i16, ptr %137, align 2, !tbaa !24
  %139 = zext i16 %138 to i64
  %140 = call ptr @page_node(ptr noundef %129, i64 noundef %139) #10
  store ptr %140, ptr %9, align 8, !tbaa !5
  %141 = load ptr, ptr %9, align 8, !tbaa !5
  %142 = call zeroext i8 @node_flags(ptr noundef %141) #10
  %143 = zext i8 %142 to i32
  %144 = and i32 %143, 4
  %145 = icmp ne i32 %144, 0
  br i1 %145, label %146, label %511

146:                                              ; preds = %128
  %147 = load i32, ptr %5, align 4, !tbaa !9
  %148 = and i32 %147, 160
  %149 = icmp ne i32 %148, 0
  br i1 %149, label %150, label %164

150:                                              ; preds = %146
  %151 = load ptr, ptr %4, align 8, !tbaa !5
  %152 = getelementptr inbounds %struct.MDBX_cursor, ptr %151, i32 0, i32 8
  %153 = load ptr, ptr %152, align 8, !tbaa !25
  %154 = getelementptr inbounds %struct.inner_cursor, ptr %153, i32 0, i32 1
  %155 = getelementptr inbounds %struct.tree, ptr %154, i32 0, i32 8
  %156 = load i64, ptr %155, align 8, !tbaa !26
  %157 = sub i64 %156, 1
  %158 = load ptr, ptr %4, align 8, !tbaa !5
  %159 = getelementptr inbounds %struct.MDBX_cursor, ptr %158, i32 0, i32 6
  %160 = load ptr, ptr %159, align 8, !tbaa !29
  %161 = getelementptr inbounds %struct.tree, ptr %160, i32 0, i32 8
  %162 = load i64, ptr %161, align 4, !tbaa !30
  %163 = sub i64 %162, %157
  store i64 %163, ptr %161, align 4, !tbaa !30
  br label %476

164:                                              ; preds = %146
  %165 = load ptr, ptr %9, align 8, !tbaa !5
  %166 = call zeroext i8 @node_flags(ptr noundef %165) #10
  %167 = zext i8 %166 to i32
  %168 = and i32 %167, 2
  %169 = icmp ne i32 %168, 0
  br i1 %169, label %219, label %170

170:                                              ; preds = %164
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #11
  %171 = load ptr, ptr %9, align 8, !tbaa !5
  %172 = call ptr @node_data(ptr noundef %171) #10
  store ptr %172, ptr %10, align 8, !tbaa !5
  br label %173

173:                                              ; preds = %170
  %174 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %175 = zext i8 %174 to i32
  %176 = and i32 %175, 1
  %177 = icmp ne i32 %176, 0
  %178 = xor i1 %177, true
  %179 = xor i1 %178, true
  %180 = zext i1 %179 to i32
  %181 = sext i32 %180 to i64
  %182 = call i64 @llvm.expect.i64(i64 %181, i64 1)
  %183 = icmp ne i64 %182, 0
  br i1 %183, label %184, label %204

184:                                              ; preds = %173
  br label %185

185:                                              ; preds = %184
  %186 = load ptr, ptr %10, align 8, !tbaa !5
  %187 = call zeroext i1 @is_subpage(ptr noundef %186) #10
  %188 = xor i1 %187, true
  %189 = xor i1 %188, true
  %190 = xor i1 %189, true
  %191 = zext i1 %190 to i32
  %192 = sext i32 %191 to i64
  %193 = call i64 @llvm.expect.i64(i64 %192, i64 0)
  %194 = icmp ne i64 %193, 0
  br i1 %194, label %195, label %201

195:                                              ; preds = %185
  %196 = load ptr, ptr %4, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.MDBX_cursor, ptr %196, i32 0, i32 5
  %198 = load ptr, ptr %197, align 8, !tbaa !16
  %199 = getelementptr inbounds %struct.MDBX_txn, ptr %198, i32 0, i32 9
  %200 = load ptr, ptr %199, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %200, ptr noundef @.str.97, ptr noundef @__func__.cursor_del, i32 noundef 1549) #13
  unreachable

201:                                              ; preds = %185
  br label %202

202:                                              ; preds = %201
  br label %203

203:                                              ; preds = %202
  br label %204

204:                                              ; preds = %203, %173
  br label %205

205:                                              ; preds = %204
  br label %206

206:                                              ; preds = %205
  %207 = load ptr, ptr %8, align 8, !tbaa !5
  %208 = getelementptr inbounds %struct.page, ptr %207, i32 0, i32 0
  %209 = load i64, ptr %208, align 1, !tbaa !31
  %210 = load ptr, ptr %10, align 8, !tbaa !5
  %211 = getelementptr inbounds %struct.page, ptr %210, i32 0, i32 0
  store i64 %209, ptr %211, align 1, !tbaa !31
  %212 = load ptr, ptr %10, align 8, !tbaa !5
  %213 = load ptr, ptr %4, align 8, !tbaa !5
  %214 = getelementptr inbounds %struct.MDBX_cursor, ptr %213, i32 0, i32 8
  %215 = load ptr, ptr %214, align 8, !tbaa !25
  %216 = getelementptr inbounds %struct.inner_cursor, ptr %215, i32 0, i32 0
  %217 = getelementptr inbounds %struct.MDBX_cursor, ptr %216, i32 0, i32 9
  %218 = getelementptr inbounds [32 x ptr], ptr %217, i64 0, i64 0
  store ptr %212, ptr %218, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #11
  br label %219

219:                                              ; preds = %206, %164
  %220 = load ptr, ptr %4, align 8, !tbaa !5
  %221 = getelementptr inbounds %struct.MDBX_cursor, ptr %220, i32 0, i32 8
  %222 = load ptr, ptr %221, align 8, !tbaa !25
  %223 = getelementptr inbounds %struct.inner_cursor, ptr %222, i32 0, i32 0
  %224 = call i32 @cursor_del(ptr noundef %223, i32 noundef 0) #12
  store i32 %224, ptr %6, align 4, !tbaa !9
  %225 = load i32, ptr %6, align 4, !tbaa !9
  %226 = icmp ne i32 %225, 0
  %227 = xor i1 %226, true
  %228 = xor i1 %227, true
  %229 = zext i1 %228 to i32
  %230 = sext i32 %229 to i64
  %231 = call i64 @llvm.expect.i64(i64 %230, i64 0)
  %232 = icmp ne i64 %231, 0
  br i1 %232, label %233, label %235

233:                                              ; preds = %219
  %234 = load i32, ptr %6, align 4, !tbaa !9
  store i32 %234, ptr %3, align 4
  store i32 1, ptr %7, align 4
  br label %1344

235:                                              ; preds = %219
  %236 = load ptr, ptr %4, align 8, !tbaa !5
  %237 = getelementptr inbounds %struct.MDBX_cursor, ptr %236, i32 0, i32 8
  %238 = load ptr, ptr %237, align 8, !tbaa !25
  %239 = getelementptr inbounds %struct.inner_cursor, ptr %238, i32 0, i32 1
  %240 = getelementptr inbounds %struct.tree, ptr %239, i32 0, i32 8
  %241 = load i64, ptr %240, align 8, !tbaa !26
  %242 = icmp ne i64 %241, 0
  br i1 %242, label %243, label %475

243:                                              ; preds = %235
  %244 = load ptr, ptr %9, align 8, !tbaa !5
  %245 = call zeroext i8 @node_flags(ptr noundef %244) #10
  %246 = zext i8 %245 to i32
  %247 = and i32 %246, 2
  %248 = icmp ne i32 %247, 0
  br i1 %248, label %249, label %266

249:                                              ; preds = %243
  %250 = load ptr, ptr %4, align 8, !tbaa !5
  %251 = getelementptr inbounds %struct.MDBX_cursor, ptr %250, i32 0, i32 5
  %252 = load ptr, ptr %251, align 8, !tbaa !16
  %253 = getelementptr inbounds %struct.MDBX_txn, ptr %252, i32 0, i32 7
  %254 = load i64, ptr %253, align 8, !tbaa !32
  %255 = load ptr, ptr %4, align 8, !tbaa !5
  %256 = getelementptr inbounds %struct.MDBX_cursor, ptr %255, i32 0, i32 8
  %257 = load ptr, ptr %256, align 8, !tbaa !25
  %258 = getelementptr inbounds %struct.inner_cursor, ptr %257, i32 0, i32 1
  %259 = getelementptr inbounds %struct.tree, ptr %258, i32 0, i32 9
  store i64 %254, ptr %259, align 8, !tbaa !33
  %260 = load ptr, ptr %9, align 8, !tbaa !5
  %261 = call ptr @node_data(ptr noundef %260) #10
  %262 = load ptr, ptr %4, align 8, !tbaa !5
  %263 = getelementptr inbounds %struct.MDBX_cursor, ptr %262, i32 0, i32 8
  %264 = load ptr, ptr %263, align 8, !tbaa !25
  %265 = getelementptr inbounds %struct.inner_cursor, ptr %264, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %261, ptr align 8 %265, i64 48, i1 false)
  br label %412

266:                                              ; preds = %243
  %267 = load ptr, ptr %8, align 8, !tbaa !5
  %268 = load ptr, ptr %4, align 8, !tbaa !5
  %269 = getelementptr inbounds %struct.MDBX_cursor, ptr %268, i32 0, i32 10
  %270 = load ptr, ptr %4, align 8, !tbaa !5
  %271 = getelementptr inbounds %struct.MDBX_cursor, ptr %270, i32 0, i32 1
  %272 = getelementptr inbounds %struct.anon, ptr %271, i32 0, i32 1
  %273 = load i8, ptr %272, align 1, !tbaa !11
  %274 = sext i8 %273 to i64
  %275 = getelementptr inbounds [32 x i16], ptr %269, i64 0, i64 %274
  %276 = load i16, ptr %275, align 2, !tbaa !24
  %277 = zext i16 %276 to i64
  %278 = load ptr, ptr %9, align 8, !tbaa !5
  %279 = call ptr @node_shrink(ptr noundef %267, i64 noundef %277, ptr noundef %278)
  store ptr %279, ptr %9, align 8, !tbaa !5
  %280 = load ptr, ptr %9, align 8, !tbaa !5
  %281 = call ptr @node_data(ptr noundef %280) #10
  %282 = load ptr, ptr %4, align 8, !tbaa !5
  %283 = getelementptr inbounds %struct.MDBX_cursor, ptr %282, i32 0, i32 8
  %284 = load ptr, ptr %283, align 8, !tbaa !25
  %285 = getelementptr inbounds %struct.inner_cursor, ptr %284, i32 0, i32 0
  %286 = getelementptr inbounds %struct.MDBX_cursor, ptr %285, i32 0, i32 9
  %287 = getelementptr inbounds [32 x ptr], ptr %286, i64 0, i64 0
  store ptr %281, ptr %287, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #11
  %288 = load ptr, ptr %4, align 8, !tbaa !5
  %289 = getelementptr inbounds %struct.MDBX_cursor, ptr %288, i32 0, i32 5
  %290 = load ptr, ptr %289, align 8, !tbaa !16
  %291 = getelementptr inbounds %struct.MDBX_txn, ptr %290, i32 0, i32 14
  %292 = load ptr, ptr %291, align 8, !tbaa !34
  %293 = load ptr, ptr %4, align 8, !tbaa !5
  %294 = call i64 @cursor_dbi(ptr noundef %293) #10
  %295 = getelementptr inbounds ptr, ptr %292, i64 %294
  %296 = load ptr, ptr %295, align 8, !tbaa !5
  store ptr %296, ptr %11, align 8, !tbaa !5
  br label %297

297:                                              ; preds = %407, %266
  %298 = load ptr, ptr %11, align 8, !tbaa !5
  %299 = icmp ne ptr %298, null
  br i1 %299, label %301, label %300

300:                                              ; preds = %297
  store i32 13, ptr %7, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #11
  br label %411

301:                                              ; preds = %297
  %302 = load ptr, ptr %4, align 8, !tbaa !5
  %303 = load ptr, ptr %11, align 8, !tbaa !5
  %304 = call zeroext i1 @is_related(ptr noundef %302, ptr noundef %303)
  br i1 %304, label %305, label %317

305:                                              ; preds = %301
  %306 = load ptr, ptr %11, align 8, !tbaa !5
  %307 = getelementptr inbounds %struct.MDBX_cursor, ptr %306, i32 0, i32 9
  %308 = load ptr, ptr %4, align 8, !tbaa !5
  %309 = getelementptr inbounds %struct.MDBX_cursor, ptr %308, i32 0, i32 1
  %310 = getelementptr inbounds %struct.anon, ptr %309, i32 0, i32 1
  %311 = load i8, ptr %310, align 1, !tbaa !11
  %312 = sext i8 %311 to i64
  %313 = getelementptr inbounds [32 x ptr], ptr %307, i64 0, i64 %312
  %314 = load ptr, ptr %313, align 8, !tbaa !5
  %315 = load ptr, ptr %8, align 8, !tbaa !5
  %316 = icmp ne ptr %314, %315
  br i1 %316, label %317, label %318

317:                                              ; preds = %305, %301
  br label %407

318:                                              ; preds = %305
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #11
  %319 = load ptr, ptr %9, align 8, !tbaa !5
  store ptr %319, ptr %12, align 8, !tbaa !5
  %320 = load ptr, ptr %11, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.MDBX_cursor, ptr %320, i32 0, i32 10
  %322 = load ptr, ptr %4, align 8, !tbaa !5
  %323 = getelementptr inbounds %struct.MDBX_cursor, ptr %322, i32 0, i32 1
  %324 = getelementptr inbounds %struct.anon, ptr %323, i32 0, i32 1
  %325 = load i8, ptr %324, align 1, !tbaa !11
  %326 = sext i8 %325 to i64
  %327 = getelementptr inbounds [32 x i16], ptr %321, i64 0, i64 %326
  %328 = load i16, ptr %327, align 2, !tbaa !24
  %329 = zext i16 %328 to i64
  %330 = load ptr, ptr %8, align 8, !tbaa !5
  %331 = call i64 @page_numkeys(ptr noundef %330) #10
  %332 = icmp uge i64 %329, %331
  %333 = xor i1 %332, true
  %334 = xor i1 %333, true
  %335 = zext i1 %334 to i32
  %336 = sext i32 %335 to i64
  %337 = call i64 @llvm.expect.i64(i64 %336, i64 0)
  %338 = icmp ne i64 %337, 0
  br i1 %338, label %339, label %353

339:                                              ; preds = %318
  %340 = load ptr, ptr %11, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.MDBX_cursor, ptr %340, i32 0, i32 1
  %342 = getelementptr inbounds %struct.anon, ptr %341, i32 0, i32 0
  store i8 -48, ptr %342, align 4, !tbaa !11
  %343 = load ptr, ptr %11, align 8, !tbaa !5
  %344 = getelementptr inbounds %struct.MDBX_cursor, ptr %343, i32 0, i32 8
  %345 = load ptr, ptr %344, align 8, !tbaa !25
  %346 = getelementptr inbounds %struct.inner_cursor, ptr %345, i32 0, i32 1
  %347 = getelementptr inbounds %struct.tree, ptr %346, i32 0, i32 3
  store i32 0, ptr %347, align 8, !tbaa !35
  %348 = load ptr, ptr %11, align 8, !tbaa !5
  %349 = getelementptr inbounds %struct.MDBX_cursor, ptr %348, i32 0, i32 8
  %350 = load ptr, ptr %349, align 8, !tbaa !25
  %351 = getelementptr inbounds %struct.inner_cursor, ptr %350, i32 0, i32 0
  %352 = getelementptr inbounds %struct.MDBX_cursor, ptr %351, i32 0, i32 1
  store i16 -47, ptr %352, align 4, !tbaa !11
  store i32 15, ptr %7, align 4
  br label %404

353:                                              ; preds = %318
  %354 = load ptr, ptr %11, align 8, !tbaa !5
  %355 = getelementptr inbounds %struct.MDBX_cursor, ptr %354, i32 0, i32 10
  %356 = load ptr, ptr %4, align 8, !tbaa !5
  %357 = getelementptr inbounds %struct.MDBX_cursor, ptr %356, i32 0, i32 1
  %358 = getelementptr inbounds %struct.anon, ptr %357, i32 0, i32 1
  %359 = load i8, ptr %358, align 1, !tbaa !11
  %360 = sext i8 %359 to i64
  %361 = getelementptr inbounds [32 x i16], ptr %355, i64 0, i64 %360
  %362 = load i16, ptr %361, align 2, !tbaa !24
  %363 = zext i16 %362 to i32
  %364 = load ptr, ptr %4, align 8, !tbaa !5
  %365 = getelementptr inbounds %struct.MDBX_cursor, ptr %364, i32 0, i32 10
  %366 = load ptr, ptr %4, align 8, !tbaa !5
  %367 = getelementptr inbounds %struct.MDBX_cursor, ptr %366, i32 0, i32 1
  %368 = getelementptr inbounds %struct.anon, ptr %367, i32 0, i32 1
  %369 = load i8, ptr %368, align 1, !tbaa !11
  %370 = sext i8 %369 to i64
  %371 = getelementptr inbounds [32 x i16], ptr %365, i64 0, i64 %370
  %372 = load i16, ptr %371, align 2, !tbaa !24
  %373 = zext i16 %372 to i32
  %374 = icmp ne i32 %363, %373
  br i1 %374, label %375, label %395

375:                                              ; preds = %353
  %376 = load ptr, ptr %8, align 8, !tbaa !5
  %377 = load ptr, ptr %11, align 8, !tbaa !5
  %378 = getelementptr inbounds %struct.MDBX_cursor, ptr %377, i32 0, i32 10
  %379 = load ptr, ptr %4, align 8, !tbaa !5
  %380 = getelementptr inbounds %struct.MDBX_cursor, ptr %379, i32 0, i32 1
  %381 = getelementptr inbounds %struct.anon, ptr %380, i32 0, i32 1
  %382 = load i8, ptr %381, align 1, !tbaa !11
  %383 = sext i8 %382 to i64
  %384 = getelementptr inbounds [32 x i16], ptr %378, i64 0, i64 %383
  %385 = load i16, ptr %384, align 2, !tbaa !24
  %386 = zext i16 %385 to i64
  %387 = call ptr @page_node(ptr noundef %376, i64 noundef %386) #10
  store ptr %387, ptr %12, align 8, !tbaa !5
  %388 = load ptr, ptr %12, align 8, !tbaa !5
  %389 = call zeroext i8 @node_flags(ptr noundef %388) #10
  %390 = zext i8 %389 to i32
  %391 = and i32 %390, 2
  %392 = icmp ne i32 %391, 0
  br i1 %392, label %393, label %394

393:                                              ; preds = %375
  store i32 15, ptr %7, align 4
  br label %404

394:                                              ; preds = %375
  br label %395

395:                                              ; preds = %394, %353
  %396 = load ptr, ptr %12, align 8, !tbaa !5
  %397 = call ptr @node_data(ptr noundef %396) #10
  %398 = load ptr, ptr %11, align 8, !tbaa !5
  %399 = getelementptr inbounds %struct.MDBX_cursor, ptr %398, i32 0, i32 8
  %400 = load ptr, ptr %399, align 8, !tbaa !25
  %401 = getelementptr inbounds %struct.inner_cursor, ptr %400, i32 0, i32 0
  %402 = getelementptr inbounds %struct.MDBX_cursor, ptr %401, i32 0, i32 9
  %403 = getelementptr inbounds [32 x ptr], ptr %402, i64 0, i64 0
  store ptr %397, ptr %403, align 8, !tbaa !5
  store i32 0, ptr %7, align 4
  br label %404

404:                                              ; preds = %395, %393, %339
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #11
  %405 = load i32, ptr %7, align 4
  switch i32 %405, label %1348 [
    i32 0, label %406
    i32 15, label %407
  ]

406:                                              ; preds = %404
  br label %407

407:                                              ; preds = %406, %404, %317
  %408 = load ptr, ptr %11, align 8, !tbaa !5
  %409 = getelementptr inbounds %struct.MDBX_cursor, ptr %408, i32 0, i32 11
  %410 = load ptr, ptr %409, align 8, !tbaa !36
  store ptr %410, ptr %11, align 8, !tbaa !5
  br label %297, !llvm.loop !37

411:                                              ; preds = %300
  br label %412

412:                                              ; preds = %411, %249
  %413 = load ptr, ptr %4, align 8, !tbaa !5
  %414 = getelementptr inbounds %struct.MDBX_cursor, ptr %413, i32 0, i32 6
  %415 = load ptr, ptr %414, align 8, !tbaa !29
  %416 = getelementptr inbounds %struct.tree, ptr %415, i32 0, i32 8
  %417 = load i64, ptr %416, align 4, !tbaa !30
  %418 = sub i64 %417, 1
  store i64 %418, ptr %416, align 4, !tbaa !30
  br label %419

419:                                              ; preds = %412
  %420 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %421 = zext i8 %420 to i32
  %422 = and i32 %421, 1
  %423 = icmp ne i32 %422, 0
  %424 = xor i1 %423, true
  %425 = xor i1 %424, true
  %426 = zext i1 %425 to i32
  %427 = sext i32 %426 to i64
  %428 = call i64 @llvm.expect.i64(i64 %427, i64 1)
  %429 = icmp ne i64 %428, 0
  br i1 %429, label %430, label %471

430:                                              ; preds = %419
  br label %431

431:                                              ; preds = %430
  %432 = load ptr, ptr %4, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct.MDBX_cursor, ptr %432, i32 0, i32 6
  %434 = load ptr, ptr %433, align 8, !tbaa !29
  %435 = getelementptr inbounds %struct.tree, ptr %434, i32 0, i32 8
  %436 = load i64, ptr %435, align 4, !tbaa !30
  %437 = icmp ugt i64 %436, 0
  br i1 %437, label %438, label %453

438:                                              ; preds = %431
  %439 = load ptr, ptr %4, align 8, !tbaa !5
  %440 = getelementptr inbounds %struct.MDBX_cursor, ptr %439, i32 0, i32 6
  %441 = load ptr, ptr %440, align 8, !tbaa !29
  %442 = getelementptr inbounds %struct.tree, ptr %441, i32 0, i32 1
  %443 = load i16, ptr %442, align 2, !tbaa !39
  %444 = zext i16 %443 to i32
  %445 = icmp sgt i32 %444, 0
  br i1 %445, label %446, label %453

446:                                              ; preds = %438
  %447 = load ptr, ptr %4, align 8, !tbaa !5
  %448 = getelementptr inbounds %struct.MDBX_cursor, ptr %447, i32 0, i32 6
  %449 = load ptr, ptr %448, align 8, !tbaa !29
  %450 = getelementptr inbounds %struct.tree, ptr %449, i32 0, i32 3
  %451 = load i32, ptr %450, align 4, !tbaa !40
  %452 = icmp ne i32 %451, -1
  br label %453

453:                                              ; preds = %446, %438, %431
  %454 = phi i1 [ false, %438 ], [ false, %431 ], [ %452, %446 ]
  %455 = xor i1 %454, true
  %456 = xor i1 %455, true
  %457 = xor i1 %456, true
  %458 = zext i1 %457 to i32
  %459 = sext i32 %458 to i64
  %460 = call i64 @llvm.expect.i64(i64 %459, i64 0)
  %461 = icmp ne i64 %460, 0
  br i1 %461, label %462, label %468

462:                                              ; preds = %453
  %463 = load ptr, ptr %4, align 8, !tbaa !5
  %464 = getelementptr inbounds %struct.MDBX_cursor, ptr %463, i32 0, i32 5
  %465 = load ptr, ptr %464, align 8, !tbaa !16
  %466 = getelementptr inbounds %struct.MDBX_txn, ptr %465, i32 0, i32 9
  %467 = load ptr, ptr %466, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %467, ptr noundef @.str.98, ptr noundef @__func__.cursor_del, i32 noundef 1586) #13
  unreachable

468:                                              ; preds = %453
  br label %469

469:                                              ; preds = %468
  br label %470

470:                                              ; preds = %469
  br label %471

471:                                              ; preds = %470, %419
  br label %472

472:                                              ; preds = %471
  br label %473

473:                                              ; preds = %472
  %474 = load i32, ptr %6, align 4, !tbaa !9
  store i32 %474, ptr %3, align 4
  store i32 1, ptr %7, align 4
  br label %1344

475:                                              ; preds = %235
  br label %476

476:                                              ; preds = %475, %150
  %477 = load ptr, ptr %9, align 8, !tbaa !5
  %478 = call zeroext i8 @node_flags(ptr noundef %477) #10
  %479 = zext i8 %478 to i32
  %480 = and i32 %479, 2
  %481 = icmp ne i32 %480, 0
  br i1 %481, label %482, label %509

482:                                              ; preds = %476
  %483 = load ptr, ptr %4, align 8, !tbaa !5
  %484 = getelementptr inbounds %struct.MDBX_cursor, ptr %483, i32 0, i32 8
  %485 = load ptr, ptr %484, align 8, !tbaa !25
  %486 = getelementptr inbounds %struct.inner_cursor, ptr %485, i32 0, i32 0
  %487 = getelementptr inbounds %struct.MDBX_cursor, ptr %486, i32 0, i32 6
  %488 = load ptr, ptr %487, align 8, !tbaa !41
  %489 = getelementptr inbounds %struct.tree, ptr %488, i32 0, i32 1
  %490 = load i16, ptr %489, align 2, !tbaa !39
  %491 = zext i16 %490 to i32
  %492 = icmp ne i32 %491, 0
  br i1 %492, label %493, label %509

493:                                              ; preds = %482
  %494 = load ptr, ptr %4, align 8, !tbaa !5
  %495 = getelementptr inbounds %struct.MDBX_cursor, ptr %494, i32 0, i32 8
  %496 = load ptr, ptr %495, align 8, !tbaa !25
  %497 = getelementptr inbounds %struct.inner_cursor, ptr %496, i32 0, i32 0
  %498 = call i32 @tree_drop(ptr noundef %497, i1 noundef zeroext false)
  store i32 %498, ptr %6, align 4, !tbaa !9
  %499 = load i32, ptr %6, align 4, !tbaa !9
  %500 = icmp ne i32 %499, 0
  %501 = xor i1 %500, true
  %502 = xor i1 %501, true
  %503 = zext i1 %502 to i32
  %504 = sext i32 %503 to i64
  %505 = call i64 @llvm.expect.i64(i64 %504, i64 0)
  %506 = icmp ne i64 %505, 0
  br i1 %506, label %507, label %508

507:                                              ; preds = %493
  br label %1336

508:                                              ; preds = %493
  br label %509

509:                                              ; preds = %508, %482, %476
  %510 = load ptr, ptr %4, align 8, !tbaa !5
  call void @inner_gone(ptr noundef %510)
  br label %562

511:                                              ; preds = %128
  br label %512

512:                                              ; preds = %511
  %513 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %514 = zext i8 %513 to i32
  %515 = and i32 %514, 1
  %516 = icmp ne i32 %515, 0
  %517 = xor i1 %516, true
  %518 = xor i1 %517, true
  %519 = zext i1 %518 to i32
  %520 = sext i32 %519 to i64
  %521 = call i64 @llvm.expect.i64(i64 %520, i64 1)
  %522 = icmp ne i64 %521, 0
  br i1 %522, label %523, label %544

523:                                              ; preds = %512
  br label %524

524:                                              ; preds = %523
  %525 = load ptr, ptr %4, align 8, !tbaa !5
  %526 = call zeroext i1 @inner_pointed(ptr noundef %525) #10
  %527 = xor i1 %526, true
  %528 = xor i1 %527, true
  %529 = xor i1 %528, true
  %530 = xor i1 %529, true
  %531 = zext i1 %530 to i32
  %532 = sext i32 %531 to i64
  %533 = call i64 @llvm.expect.i64(i64 %532, i64 0)
  %534 = icmp ne i64 %533, 0
  br i1 %534, label %535, label %541

535:                                              ; preds = %524
  %536 = load ptr, ptr %4, align 8, !tbaa !5
  %537 = getelementptr inbounds %struct.MDBX_cursor, ptr %536, i32 0, i32 5
  %538 = load ptr, ptr %537, align 8, !tbaa !16
  %539 = getelementptr inbounds %struct.MDBX_txn, ptr %538, i32 0, i32 9
  %540 = load ptr, ptr %539, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %540, ptr noundef @.str.99, ptr noundef @__func__.cursor_del, i32 noundef 1600) #13
  unreachable

541:                                              ; preds = %524
  br label %542

542:                                              ; preds = %541
  br label %543

543:                                              ; preds = %542
  br label %544

544:                                              ; preds = %543, %512
  br label %545

545:                                              ; preds = %544
  br label %546

546:                                              ; preds = %545
  %547 = load ptr, ptr %9, align 8, !tbaa !5
  %548 = call zeroext i8 @node_flags(ptr noundef %547) #10
  %549 = zext i8 %548 to i32
  %550 = load i32, ptr %5, align 4, !tbaa !9
  %551 = xor i32 %549, %550
  %552 = and i32 %551, 2
  %553 = icmp ne i32 %552, 0
  %554 = xor i1 %553, true
  %555 = xor i1 %554, true
  %556 = zext i1 %555 to i32
  %557 = sext i32 %556 to i64
  %558 = call i64 @llvm.expect.i64(i64 %557, i64 0)
  %559 = icmp ne i64 %558, 0
  br i1 %559, label %560, label %561

560:                                              ; preds = %546
  store i32 -30784, ptr %3, align 4
  store i32 1, ptr %7, align 4
  br label %1344

561:                                              ; preds = %546
  br label %562

562:                                              ; preds = %561, %509
  %563 = load ptr, ptr %9, align 8, !tbaa !5
  %564 = call zeroext i8 @node_flags(ptr noundef %563) #10
  %565 = zext i8 %564 to i32
  %566 = and i32 %565, 1
  %567 = icmp ne i32 %566, 0
  br i1 %567, label %568, label %602

568:                                              ; preds = %562
  call void @llvm.lifetime.start.p0(i64 16, ptr %13) #11
  %569 = load ptr, ptr %4, align 8, !tbaa !5
  %570 = load ptr, ptr %9, align 8, !tbaa !5
  %571 = call i32 @node_largedata_pgno(ptr noundef %570) #10
  %572 = load ptr, ptr %8, align 8, !tbaa !5
  %573 = getelementptr inbounds %struct.page, ptr %572, i32 0, i32 0
  %574 = load i64, ptr %573, align 1, !tbaa !31
  %575 = call { ptr, i32 } @page_get_large(ptr noundef %569, i32 noundef %571, i64 noundef %574)
  %576 = getelementptr inbounds { ptr, i32 }, ptr %13, i32 0, i32 0
  %577 = extractvalue { ptr, i32 } %575, 0
  store ptr %577, ptr %576, align 8
  %578 = getelementptr inbounds { ptr, i32 }, ptr %13, i32 0, i32 1
  %579 = extractvalue { ptr, i32 } %575, 1
  store i32 %579, ptr %578, align 8
  %580 = getelementptr inbounds %struct.page_get_result, ptr %13, i32 0, i32 1
  %581 = load i32, ptr %580, align 8, !tbaa !42
  store i32 %581, ptr %6, align 4, !tbaa !9
  %582 = icmp ne i32 %581, 0
  br i1 %582, label %589, label %583

583:                                              ; preds = %568
  %584 = load ptr, ptr %4, align 8, !tbaa !5
  %585 = getelementptr inbounds %struct.page_get_result, ptr %13, i32 0, i32 0
  %586 = load ptr, ptr %585, align 8, !tbaa !44
  %587 = call i32 @page_retire(ptr noundef %584, ptr noundef %586)
  store i32 %587, ptr %6, align 4, !tbaa !9
  %588 = icmp ne i32 %587, 0
  br label %589

589:                                              ; preds = %583, %568
  %590 = phi i1 [ true, %568 ], [ %588, %583 ]
  %591 = xor i1 %590, true
  %592 = xor i1 %591, true
  %593 = zext i1 %592 to i32
  %594 = sext i32 %593 to i64
  %595 = call i64 @llvm.expect.i64(i64 %594, i64 0)
  %596 = icmp ne i64 %595, 0
  br i1 %596, label %597, label %598

597:                                              ; preds = %589
  store i32 20, ptr %7, align 4
  br label %599

598:                                              ; preds = %589
  store i32 0, ptr %7, align 4
  br label %599

599:                                              ; preds = %598, %597
  call void @llvm.lifetime.end.p0(i64 16, ptr %13) #11
  %600 = load i32, ptr %7, align 4
  switch i32 %600, label %1344 [
    i32 0, label %601
    i32 20, label %1336
  ]

601:                                              ; preds = %599
  br label %602

602:                                              ; preds = %601, %562
  br label %603

603:                                              ; preds = %602, %127
  %604 = load ptr, ptr %4, align 8, !tbaa !5
  %605 = getelementptr inbounds %struct.MDBX_cursor, ptr %604, i32 0, i32 6
  %606 = load ptr, ptr %605, align 8, !tbaa !29
  %607 = getelementptr inbounds %struct.tree, ptr %606, i32 0, i32 8
  %608 = load i64, ptr %607, align 4, !tbaa !30
  %609 = sub i64 %608, 1
  store i64 %609, ptr %607, align 4, !tbaa !30
  %610 = load ptr, ptr %4, align 8, !tbaa !5
  %611 = call i64 @cursor_dbi(ptr noundef %610) #10
  %612 = trunc i64 %611 to i32
  store i32 %612, ptr %14, align 4, !tbaa !9
  %613 = load ptr, ptr %4, align 8, !tbaa !5
  %614 = getelementptr inbounds %struct.MDBX_cursor, ptr %613, i32 0, i32 10
  %615 = load ptr, ptr %4, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.MDBX_cursor, ptr %615, i32 0, i32 1
  %617 = getelementptr inbounds %struct.anon, ptr %616, i32 0, i32 1
  %618 = load i8, ptr %617, align 1, !tbaa !11
  %619 = sext i8 %618 to i64
  %620 = getelementptr inbounds [32 x i16], ptr %614, i64 0, i64 %619
  %621 = load i16, ptr %620, align 2, !tbaa !24
  store i16 %621, ptr %15, align 2, !tbaa !24
  %622 = load ptr, ptr %4, align 8, !tbaa !5
  %623 = getelementptr inbounds %struct.MDBX_cursor, ptr %622, i32 0, i32 9
  %624 = load ptr, ptr %4, align 8, !tbaa !5
  %625 = getelementptr inbounds %struct.MDBX_cursor, ptr %624, i32 0, i32 1
  %626 = getelementptr inbounds %struct.anon, ptr %625, i32 0, i32 1
  %627 = load i8, ptr %626, align 1, !tbaa !11
  %628 = sext i8 %627 to i64
  %629 = getelementptr inbounds [32 x ptr], ptr %623, i64 0, i64 %628
  %630 = load ptr, ptr %629, align 8, !tbaa !5
  store ptr %630, ptr %8, align 8, !tbaa !5
  br label %631

631:                                              ; preds = %603
  %632 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %633 = zext i8 %632 to i32
  %634 = and i32 %633, 1
  %635 = icmp ne i32 %634, 0
  %636 = xor i1 %635, true
  %637 = xor i1 %636, true
  %638 = zext i1 %637 to i32
  %639 = sext i32 %638 to i64
  %640 = call i64 @llvm.expect.i64(i64 %639, i64 1)
  %641 = icmp ne i64 %640, 0
  br i1 %641, label %642, label %662

642:                                              ; preds = %631
  br label %643

643:                                              ; preds = %642
  %644 = load ptr, ptr %8, align 8, !tbaa !5
  %645 = call zeroext i1 @is_leaf(ptr noundef %644) #10
  %646 = xor i1 %645, true
  %647 = xor i1 %646, true
  %648 = xor i1 %647, true
  %649 = zext i1 %648 to i32
  %650 = sext i32 %649 to i64
  %651 = call i64 @llvm.expect.i64(i64 %650, i64 0)
  %652 = icmp ne i64 %651, 0
  br i1 %652, label %653, label %659

653:                                              ; preds = %643
  %654 = load ptr, ptr %4, align 8, !tbaa !5
  %655 = getelementptr inbounds %struct.MDBX_cursor, ptr %654, i32 0, i32 5
  %656 = load ptr, ptr %655, align 8, !tbaa !16
  %657 = getelementptr inbounds %struct.MDBX_txn, ptr %656, i32 0, i32 9
  %658 = load ptr, ptr %657, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %658, ptr noundef @.str.100, ptr noundef @__func__.cursor_del, i32 noundef 1618) #13
  unreachable

659:                                              ; preds = %643
  br label %660

660:                                              ; preds = %659
  br label %661

661:                                              ; preds = %660
  br label %662

662:                                              ; preds = %661, %631
  br label %663

663:                                              ; preds = %662
  br label %664

664:                                              ; preds = %663
  %665 = load ptr, ptr %4, align 8, !tbaa !5
  %666 = load ptr, ptr %4, align 8, !tbaa !5
  %667 = getelementptr inbounds %struct.MDBX_cursor, ptr %666, i32 0, i32 6
  %668 = load ptr, ptr %667, align 8, !tbaa !29
  %669 = getelementptr inbounds %struct.tree, ptr %668, i32 0, i32 2
  %670 = load i32, ptr %669, align 4, !tbaa !45
  %671 = zext i32 %670 to i64
  call void @node_del(ptr noundef %665, i64 noundef %671)
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #11
  %672 = load ptr, ptr %4, align 8, !tbaa !5
  %673 = getelementptr inbounds %struct.MDBX_cursor, ptr %672, i32 0, i32 5
  %674 = load ptr, ptr %673, align 8, !tbaa !16
  %675 = getelementptr inbounds %struct.MDBX_txn, ptr %674, i32 0, i32 14
  %676 = load ptr, ptr %675, align 8, !tbaa !34
  %677 = load i32, ptr %14, align 4, !tbaa !9
  %678 = zext i32 %677 to i64
  %679 = getelementptr inbounds ptr, ptr %676, i64 %678
  %680 = load ptr, ptr %679, align 8, !tbaa !5
  store ptr %680, ptr %16, align 8, !tbaa !5
  br label %681

681:                                              ; preds = %796, %664
  %682 = load ptr, ptr %16, align 8, !tbaa !5
  %683 = icmp ne ptr %682, null
  br i1 %683, label %685, label %684

684:                                              ; preds = %681
  store i32 29, ptr %7, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #11
  br label %800

685:                                              ; preds = %681
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #11
  %686 = load ptr, ptr %4, align 8, !tbaa !5
  %687 = getelementptr inbounds %struct.MDBX_cursor, ptr %686, i32 0, i32 1
  %688 = getelementptr inbounds %struct.anon, ptr %687, i32 0, i32 0
  %689 = load i8, ptr %688, align 4, !tbaa !11
  %690 = sext i8 %689 to i32
  %691 = and i32 %690, 1
  %692 = icmp ne i32 %691, 0
  br i1 %692, label %693, label %698

693:                                              ; preds = %685
  %694 = load ptr, ptr %16, align 8, !tbaa !5
  %695 = getelementptr inbounds %struct.MDBX_cursor, ptr %694, i32 0, i32 8
  %696 = load ptr, ptr %695, align 8, !tbaa !25
  %697 = getelementptr inbounds %struct.inner_cursor, ptr %696, i32 0, i32 0
  br label %700

698:                                              ; preds = %685
  %699 = load ptr, ptr %16, align 8, !tbaa !5
  br label %700

700:                                              ; preds = %698, %693
  %701 = phi ptr [ %697, %693 ], [ %699, %698 ]
  store ptr %701, ptr %17, align 8, !tbaa !5
  %702 = load ptr, ptr %4, align 8, !tbaa !5
  %703 = load ptr, ptr %17, align 8, !tbaa !5
  %704 = call zeroext i1 @is_related(ptr noundef %702, ptr noundef %703)
  br i1 %704, label %705, label %717

705:                                              ; preds = %700
  %706 = load ptr, ptr %17, align 8, !tbaa !5
  %707 = getelementptr inbounds %struct.MDBX_cursor, ptr %706, i32 0, i32 9
  %708 = load ptr, ptr %4, align 8, !tbaa !5
  %709 = getelementptr inbounds %struct.MDBX_cursor, ptr %708, i32 0, i32 1
  %710 = getelementptr inbounds %struct.anon, ptr %709, i32 0, i32 1
  %711 = load i8, ptr %710, align 1, !tbaa !11
  %712 = sext i8 %711 to i64
  %713 = getelementptr inbounds [32 x ptr], ptr %707, i64 0, i64 %712
  %714 = load ptr, ptr %713, align 8, !tbaa !5
  %715 = load ptr, ptr %8, align 8, !tbaa !5
  %716 = icmp ne ptr %714, %715
  br i1 %716, label %717, label %718

717:                                              ; preds = %705, %700
  store i32 31, ptr %7, align 4
  br label %793

718:                                              ; preds = %705
  %719 = load ptr, ptr %17, align 8, !tbaa !5
  %720 = getelementptr inbounds %struct.MDBX_cursor, ptr %719, i32 0, i32 10
  %721 = load ptr, ptr %4, align 8, !tbaa !5
  %722 = getelementptr inbounds %struct.MDBX_cursor, ptr %721, i32 0, i32 1
  %723 = getelementptr inbounds %struct.anon, ptr %722, i32 0, i32 1
  %724 = load i8, ptr %723, align 1, !tbaa !11
  %725 = sext i8 %724 to i64
  %726 = getelementptr inbounds [32 x i16], ptr %720, i64 0, i64 %725
  %727 = load i16, ptr %726, align 2, !tbaa !24
  %728 = zext i16 %727 to i32
  %729 = load i16, ptr %15, align 2, !tbaa !24
  %730 = zext i16 %729 to i32
  %731 = icmp eq i32 %728, %730
  br i1 %731, label %732, label %741

732:                                              ; preds = %718
  %733 = load ptr, ptr %17, align 8, !tbaa !5
  %734 = getelementptr inbounds %struct.MDBX_cursor, ptr %733, i32 0, i32 1
  %735 = getelementptr inbounds %struct.anon, ptr %734, i32 0, i32 0
  %736 = load i8, ptr %735, align 4, !tbaa !11
  %737 = sext i8 %736 to i32
  %738 = or i32 %737, 8
  %739 = trunc i32 %738 to i8
  store i8 %739, ptr %735, align 4, !tbaa !11
  %740 = load ptr, ptr %17, align 8, !tbaa !5
  call void @inner_gone(ptr noundef %740)
  br label %792

741:                                              ; preds = %718
  %742 = load ptr, ptr %17, align 8, !tbaa !5
  %743 = getelementptr inbounds %struct.MDBX_cursor, ptr %742, i32 0, i32 10
  %744 = load ptr, ptr %4, align 8, !tbaa !5
  %745 = getelementptr inbounds %struct.MDBX_cursor, ptr %744, i32 0, i32 1
  %746 = getelementptr inbounds %struct.anon, ptr %745, i32 0, i32 1
  %747 = load i8, ptr %746, align 1, !tbaa !11
  %748 = sext i8 %747 to i64
  %749 = getelementptr inbounds [32 x i16], ptr %743, i64 0, i64 %748
  %750 = load i16, ptr %749, align 2, !tbaa !24
  %751 = zext i16 %750 to i32
  %752 = load i16, ptr %15, align 2, !tbaa !24
  %753 = zext i16 %752 to i32
  %754 = icmp sgt i32 %751, %753
  %755 = zext i1 %754 to i32
  %756 = load ptr, ptr %17, align 8, !tbaa !5
  %757 = getelementptr inbounds %struct.MDBX_cursor, ptr %756, i32 0, i32 10
  %758 = load ptr, ptr %4, align 8, !tbaa !5
  %759 = getelementptr inbounds %struct.MDBX_cursor, ptr %758, i32 0, i32 1
  %760 = getelementptr inbounds %struct.anon, ptr %759, i32 0, i32 1
  %761 = load i8, ptr %760, align 1, !tbaa !11
  %762 = sext i8 %761 to i64
  %763 = getelementptr inbounds [32 x i16], ptr %757, i64 0, i64 %762
  %764 = load i16, ptr %763, align 2, !tbaa !24
  %765 = zext i16 %764 to i32
  %766 = sub nsw i32 %765, %755
  %767 = trunc i32 %766 to i16
  store i16 %767, ptr %763, align 2, !tbaa !24
  %768 = load ptr, ptr %17, align 8, !tbaa !5
  %769 = call zeroext i1 @inner_pointed(ptr noundef %768) #10
  br i1 %769, label %770, label %791

770:                                              ; preds = %741
  %771 = load ptr, ptr %17, align 8, !tbaa !5
  %772 = load ptr, ptr %17, align 8, !tbaa !5
  %773 = getelementptr inbounds %struct.MDBX_cursor, ptr %772, i32 0, i32 9
  %774 = load ptr, ptr %4, align 8, !tbaa !5
  %775 = getelementptr inbounds %struct.MDBX_cursor, ptr %774, i32 0, i32 1
  %776 = getelementptr inbounds %struct.anon, ptr %775, i32 0, i32 1
  %777 = load i8, ptr %776, align 1, !tbaa !11
  %778 = sext i8 %777 to i64
  %779 = getelementptr inbounds [32 x ptr], ptr %773, i64 0, i64 %778
  %780 = load ptr, ptr %779, align 8, !tbaa !5
  %781 = load ptr, ptr %17, align 8, !tbaa !5
  %782 = getelementptr inbounds %struct.MDBX_cursor, ptr %781, i32 0, i32 10
  %783 = load ptr, ptr %4, align 8, !tbaa !5
  %784 = getelementptr inbounds %struct.MDBX_cursor, ptr %783, i32 0, i32 1
  %785 = getelementptr inbounds %struct.anon, ptr %784, i32 0, i32 1
  %786 = load i8, ptr %785, align 1, !tbaa !11
  %787 = sext i8 %786 to i64
  %788 = getelementptr inbounds [32 x i16], ptr %782, i64 0, i64 %787
  %789 = load i16, ptr %788, align 2, !tbaa !24
  %790 = zext i16 %789 to i32
  call void @cursor_inner_refresh(ptr noundef %771, ptr noundef %780, i32 noundef %790)
  br label %791

791:                                              ; preds = %770, %741
  br label %792

792:                                              ; preds = %791, %732
  store i32 0, ptr %7, align 4
  br label %793

793:                                              ; preds = %792, %717
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #11
  %794 = load i32, ptr %7, align 4
  switch i32 %794, label %1348 [
    i32 0, label %795
    i32 31, label %796
  ]

795:                                              ; preds = %793
  br label %796

796:                                              ; preds = %795, %793
  %797 = load ptr, ptr %16, align 8, !tbaa !5
  %798 = getelementptr inbounds %struct.MDBX_cursor, ptr %797, i32 0, i32 11
  %799 = load ptr, ptr %798, align 8, !tbaa !36
  store ptr %799, ptr %16, align 8, !tbaa !5
  br label %681, !llvm.loop !46

800:                                              ; preds = %684
  %801 = load ptr, ptr %4, align 8, !tbaa !5
  %802 = call i32 @tree_rebalance(ptr noundef %801)
  store i32 %802, ptr %6, align 4, !tbaa !9
  %803 = load i32, ptr %6, align 4, !tbaa !9
  %804 = icmp ne i32 %803, 0
  %805 = xor i1 %804, true
  %806 = xor i1 %805, true
  %807 = zext i1 %806 to i32
  %808 = sext i32 %807 to i64
  %809 = call i64 @llvm.expect.i64(i64 %808, i64 0)
  %810 = icmp ne i64 %809, 0
  br i1 %810, label %811, label %812

811:                                              ; preds = %800
  br label %1336

812:                                              ; preds = %800
  %813 = load ptr, ptr %4, align 8, !tbaa !5
  %814 = getelementptr inbounds %struct.MDBX_cursor, ptr %813, i32 0, i32 1
  %815 = getelementptr inbounds %struct.anon, ptr %814, i32 0, i32 0
  %816 = load i8, ptr %815, align 4, !tbaa !11
  %817 = sext i8 %816 to i32
  %818 = or i32 %817, 8
  %819 = trunc i32 %818 to i8
  store i8 %819, ptr %815, align 4, !tbaa !11
  %820 = load ptr, ptr %4, align 8, !tbaa !5
  call void @inner_gone(ptr noundef %820)
  %821 = load ptr, ptr %4, align 8, !tbaa !5
  %822 = getelementptr inbounds %struct.MDBX_cursor, ptr %821, i32 0, i32 1
  %823 = getelementptr inbounds %struct.anon, ptr %822, i32 0, i32 1
  %824 = load i8, ptr %823, align 1, !tbaa !11
  %825 = sext i8 %824 to i32
  %826 = icmp slt i32 %825, 0
  %827 = xor i1 %826, true
  %828 = xor i1 %827, true
  %829 = zext i1 %828 to i32
  %830 = sext i32 %829 to i64
  %831 = call i64 @llvm.expect.i64(i64 %830, i64 0)
  %832 = icmp ne i64 %831, 0
  br i1 %832, label %833, label %898

833:                                              ; preds = %812
  br label %834

834:                                              ; preds = %833
  %835 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %836 = zext i8 %835 to i32
  %837 = and i32 %836, 1
  %838 = icmp ne i32 %837, 0
  %839 = xor i1 %838, true
  %840 = xor i1 %839, true
  %841 = zext i1 %840 to i32
  %842 = sext i32 %841 to i64
  %843 = call i64 @llvm.expect.i64(i64 %842, i64 1)
  %844 = icmp ne i64 %843, 0
  br i1 %844, label %845, label %895

845:                                              ; preds = %834
  br label %846

846:                                              ; preds = %845
  %847 = load ptr, ptr %4, align 8, !tbaa !5
  %848 = getelementptr inbounds %struct.MDBX_cursor, ptr %847, i32 0, i32 6
  %849 = load ptr, ptr %848, align 8, !tbaa !29
  %850 = getelementptr inbounds %struct.tree, ptr %849, i32 0, i32 8
  %851 = load i64, ptr %850, align 4, !tbaa !30
  %852 = icmp eq i64 %851, 0
  br i1 %852, label %853, label %877

853:                                              ; preds = %846
  %854 = load ptr, ptr %4, align 8, !tbaa !5
  %855 = getelementptr inbounds %struct.MDBX_cursor, ptr %854, i32 0, i32 6
  %856 = load ptr, ptr %855, align 8, !tbaa !29
  %857 = getelementptr inbounds %struct.tree, ptr %856, i32 0, i32 3
  %858 = load i32, ptr %857, align 4, !tbaa !40
  %859 = icmp eq i32 %858, -1
  br i1 %859, label %870, label %860

860:                                              ; preds = %853
  %861 = load ptr, ptr %4, align 8, !tbaa !5
  %862 = call zeroext i1 @is_inner(ptr noundef %861) #10
  br i1 %862, label %863, label %877

863:                                              ; preds = %860
  %864 = load ptr, ptr %4, align 8, !tbaa !5
  %865 = getelementptr inbounds %struct.MDBX_cursor, ptr %864, i32 0, i32 6
  %866 = load ptr, ptr %865, align 8, !tbaa !29
  %867 = getelementptr inbounds %struct.tree, ptr %866, i32 0, i32 3
  %868 = load i32, ptr %867, align 4, !tbaa !40
  %869 = icmp ne i32 %868, 0
  br i1 %869, label %877, label %870

870:                                              ; preds = %863, %853
  %871 = load ptr, ptr %4, align 8, !tbaa !5
  %872 = getelementptr inbounds %struct.MDBX_cursor, ptr %871, i32 0, i32 1
  %873 = getelementptr inbounds %struct.anon, ptr %872, i32 0, i32 0
  %874 = load i8, ptr %873, align 4, !tbaa !11
  %875 = sext i8 %874 to i32
  %876 = icmp slt i32 %875, 0
  br label %877

877:                                              ; preds = %870, %863, %860, %846
  %878 = phi i1 [ false, %863 ], [ false, %860 ], [ false, %846 ], [ %876, %870 ]
  %879 = xor i1 %878, true
  %880 = xor i1 %879, true
  %881 = xor i1 %880, true
  %882 = zext i1 %881 to i32
  %883 = sext i32 %882 to i64
  %884 = call i64 @llvm.expect.i64(i64 %883, i64 0)
  %885 = icmp ne i64 %884, 0
  br i1 %885, label %886, label %892

886:                                              ; preds = %877
  %887 = load ptr, ptr %4, align 8, !tbaa !5
  %888 = getelementptr inbounds %struct.MDBX_cursor, ptr %887, i32 0, i32 5
  %889 = load ptr, ptr %888, align 8, !tbaa !16
  %890 = getelementptr inbounds %struct.MDBX_txn, ptr %889, i32 0, i32 9
  %891 = load ptr, ptr %890, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %891, ptr noundef @.str.101, ptr noundef @__func__.cursor_del, i32 noundef 1647) #13
  unreachable

892:                                              ; preds = %877
  br label %893

893:                                              ; preds = %892
  br label %894

894:                                              ; preds = %893
  br label %895

895:                                              ; preds = %894, %834
  br label %896

896:                                              ; preds = %895
  br label %897

897:                                              ; preds = %896
  store i32 0, ptr %3, align 4
  store i32 1, ptr %7, align 4
  br label %1344

898:                                              ; preds = %812
  %899 = load ptr, ptr %4, align 8, !tbaa !5
  %900 = getelementptr inbounds %struct.MDBX_cursor, ptr %899, i32 0, i32 10
  %901 = load ptr, ptr %4, align 8, !tbaa !5
  %902 = getelementptr inbounds %struct.MDBX_cursor, ptr %901, i32 0, i32 1
  %903 = getelementptr inbounds %struct.anon, ptr %902, i32 0, i32 1
  %904 = load i8, ptr %903, align 1, !tbaa !11
  %905 = sext i8 %904 to i64
  %906 = getelementptr inbounds [32 x i16], ptr %900, i64 0, i64 %905
  %907 = load i16, ptr %906, align 2, !tbaa !24
  store i16 %907, ptr %15, align 2, !tbaa !24
  %908 = load ptr, ptr %4, align 8, !tbaa !5
  %909 = getelementptr inbounds %struct.MDBX_cursor, ptr %908, i32 0, i32 9
  %910 = load ptr, ptr %4, align 8, !tbaa !5
  %911 = getelementptr inbounds %struct.MDBX_cursor, ptr %910, i32 0, i32 1
  %912 = getelementptr inbounds %struct.anon, ptr %911, i32 0, i32 1
  %913 = load i8, ptr %912, align 1, !tbaa !11
  %914 = sext i8 %913 to i64
  %915 = getelementptr inbounds [32 x ptr], ptr %909, i64 0, i64 %914
  %916 = load ptr, ptr %915, align 8, !tbaa !5
  store ptr %916, ptr %8, align 8, !tbaa !5
  br label %917

917:                                              ; preds = %898
  %918 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %919 = zext i8 %918 to i32
  %920 = and i32 %919, 1
  %921 = icmp ne i32 %920, 0
  %922 = xor i1 %921, true
  %923 = xor i1 %922, true
  %924 = zext i1 %923 to i32
  %925 = sext i32 %924 to i64
  %926 = call i64 @llvm.expect.i64(i64 %925, i64 1)
  %927 = icmp ne i64 %926, 0
  br i1 %927, label %928, label %956

928:                                              ; preds = %917
  br label %929

929:                                              ; preds = %928
  %930 = load ptr, ptr %4, align 8, !tbaa !5
  %931 = getelementptr inbounds %struct.MDBX_cursor, ptr %930, i32 0, i32 9
  %932 = load ptr, ptr %4, align 8, !tbaa !5
  %933 = getelementptr inbounds %struct.MDBX_cursor, ptr %932, i32 0, i32 1
  %934 = getelementptr inbounds %struct.anon, ptr %933, i32 0, i32 1
  %935 = load i8, ptr %934, align 1, !tbaa !11
  %936 = sext i8 %935 to i64
  %937 = getelementptr inbounds [32 x ptr], ptr %931, i64 0, i64 %936
  %938 = load ptr, ptr %937, align 8, !tbaa !5
  %939 = call zeroext i1 @is_leaf(ptr noundef %938) #10
  %940 = xor i1 %939, true
  %941 = xor i1 %940, true
  %942 = xor i1 %941, true
  %943 = zext i1 %942 to i32
  %944 = sext i32 %943 to i64
  %945 = call i64 @llvm.expect.i64(i64 %944, i64 0)
  %946 = icmp ne i64 %945, 0
  br i1 %946, label %947, label %953

947:                                              ; preds = %929
  %948 = load ptr, ptr %4, align 8, !tbaa !5
  %949 = getelementptr inbounds %struct.MDBX_cursor, ptr %948, i32 0, i32 5
  %950 = load ptr, ptr %949, align 8, !tbaa !16
  %951 = getelementptr inbounds %struct.MDBX_txn, ptr %950, i32 0, i32 9
  %952 = load ptr, ptr %951, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %952, ptr noundef @.str.102, ptr noundef @__func__.cursor_del, i32 noundef 1653) #13
  unreachable

953:                                              ; preds = %929
  br label %954

954:                                              ; preds = %953
  br label %955

955:                                              ; preds = %954
  br label %956

956:                                              ; preds = %955, %917
  br label %957

957:                                              ; preds = %956
  br label %958

958:                                              ; preds = %957
  %959 = load ptr, ptr %8, align 8, !tbaa !5
  %960 = call i64 @page_numkeys(ptr noundef %959) #10
  store i64 %960, ptr %18, align 8, !tbaa !31
  br label %961

961:                                              ; preds = %958
  %962 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %963 = zext i8 %962 to i32
  %964 = and i32 %963, 1
  %965 = icmp ne i32 %964, 0
  %966 = xor i1 %965, true
  %967 = xor i1 %966, true
  %968 = zext i1 %967 to i32
  %969 = sext i32 %968 to i64
  %970 = call i64 @llvm.expect.i64(i64 %969, i64 1)
  %971 = icmp ne i64 %970, 0
  br i1 %971, label %972, label %1021

972:                                              ; preds = %961
  br label %973

973:                                              ; preds = %972
  %974 = load ptr, ptr %4, align 8, !tbaa !5
  %975 = getelementptr inbounds %struct.MDBX_cursor, ptr %974, i32 0, i32 6
  %976 = load ptr, ptr %975, align 8, !tbaa !29
  %977 = getelementptr inbounds %struct.tree, ptr %976, i32 0, i32 8
  %978 = load i64, ptr %977, align 4, !tbaa !30
  %979 = icmp ugt i64 %978, 0
  br i1 %979, label %980, label %983

980:                                              ; preds = %973
  %981 = load i64, ptr %18, align 8, !tbaa !31
  %982 = icmp ugt i64 %981, 0
  br i1 %982, label %1003, label %983

983:                                              ; preds = %980, %973
  %984 = load ptr, ptr %4, align 8, !tbaa !5
  %985 = getelementptr inbounds %struct.MDBX_cursor, ptr %984, i32 0, i32 1
  %986 = getelementptr inbounds %struct.anon, ptr %985, i32 0, i32 0
  %987 = load i8, ptr %986, align 4, !tbaa !11
  %988 = sext i8 %987 to i32
  %989 = and i32 %988, 1
  %990 = icmp ne i32 %989, 0
  br i1 %990, label %991, label %1001

991:                                              ; preds = %983
  %992 = load ptr, ptr %4, align 8, !tbaa !5
  %993 = getelementptr inbounds %struct.MDBX_cursor, ptr %992, i32 0, i32 6
  %994 = load ptr, ptr %993, align 8, !tbaa !29
  %995 = getelementptr inbounds %struct.tree, ptr %994, i32 0, i32 8
  %996 = load i64, ptr %995, align 4, !tbaa !30
  %997 = icmp eq i64 %996, 0
  br i1 %997, label %998, label %1001

998:                                              ; preds = %991
  %999 = load i64, ptr %18, align 8, !tbaa !31
  %1000 = icmp eq i64 %999, 0
  br label %1001

1001:                                             ; preds = %998, %991, %983
  %1002 = phi i1 [ false, %991 ], [ false, %983 ], [ %1000, %998 ]
  br label %1003

1003:                                             ; preds = %1001, %980
  %1004 = phi i1 [ true, %980 ], [ %1002, %1001 ]
  %1005 = xor i1 %1004, true
  %1006 = xor i1 %1005, true
  %1007 = xor i1 %1006, true
  %1008 = zext i1 %1007 to i32
  %1009 = sext i32 %1008 to i64
  %1010 = call i64 @llvm.expect.i64(i64 %1009, i64 0)
  %1011 = icmp ne i64 %1010, 0
  br i1 %1011, label %1012, label %1018

1012:                                             ; preds = %1003
  %1013 = load ptr, ptr %4, align 8, !tbaa !5
  %1014 = getelementptr inbounds %struct.MDBX_cursor, ptr %1013, i32 0, i32 5
  %1015 = load ptr, ptr %1014, align 8, !tbaa !16
  %1016 = getelementptr inbounds %struct.MDBX_txn, ptr %1015, i32 0, i32 9
  %1017 = load ptr, ptr %1016, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %1017, ptr noundef @.str.103, ptr noundef @__func__.cursor_del, i32 noundef 1655) #13
  unreachable

1018:                                             ; preds = %1003
  br label %1019

1019:                                             ; preds = %1018
  br label %1020

1020:                                             ; preds = %1019
  br label %1021

1021:                                             ; preds = %1020, %961
  br label %1022

1022:                                             ; preds = %1021
  br label %1023

1023:                                             ; preds = %1022
  %1024 = load ptr, ptr %4, align 8, !tbaa !5
  %1025 = getelementptr inbounds %struct.MDBX_cursor, ptr %1024, i32 0, i32 1
  %1026 = getelementptr inbounds %struct.anon, ptr %1025, i32 0, i32 1
  %1027 = load i8, ptr %1026, align 1, !tbaa !11
  %1028 = sext i8 %1027 to i64
  store i64 %1028, ptr %19, align 8, !tbaa !31
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #11
  %1029 = load ptr, ptr %4, align 8, !tbaa !5
  %1030 = getelementptr inbounds %struct.MDBX_cursor, ptr %1029, i32 0, i32 5
  %1031 = load ptr, ptr %1030, align 8, !tbaa !16
  %1032 = getelementptr inbounds %struct.MDBX_txn, ptr %1031, i32 0, i32 14
  %1033 = load ptr, ptr %1032, align 8, !tbaa !34
  %1034 = load i32, ptr %14, align 4, !tbaa !9
  %1035 = zext i32 %1034 to i64
  %1036 = getelementptr inbounds ptr, ptr %1033, i64 %1035
  %1037 = load ptr, ptr %1036, align 8, !tbaa !5
  store ptr %1037, ptr %20, align 8, !tbaa !5
  br label %1038

1038:                                             ; preds = %1280, %1023
  %1039 = load ptr, ptr %20, align 8, !tbaa !5
  %1040 = icmp ne ptr %1039, null
  br i1 %1040, label %1042, label %1041

1041:                                             ; preds = %1038
  store i32 44, ptr %7, align 4
  br label %1284

1042:                                             ; preds = %1038
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #11
  %1043 = load ptr, ptr %4, align 8, !tbaa !5
  %1044 = getelementptr inbounds %struct.MDBX_cursor, ptr %1043, i32 0, i32 1
  %1045 = getelementptr inbounds %struct.anon, ptr %1044, i32 0, i32 0
  %1046 = load i8, ptr %1045, align 4, !tbaa !11
  %1047 = sext i8 %1046 to i32
  %1048 = and i32 %1047, 1
  %1049 = icmp ne i32 %1048, 0
  br i1 %1049, label %1050, label %1055

1050:                                             ; preds = %1042
  %1051 = load ptr, ptr %20, align 8, !tbaa !5
  %1052 = getelementptr inbounds %struct.MDBX_cursor, ptr %1051, i32 0, i32 8
  %1053 = load ptr, ptr %1052, align 8, !tbaa !25
  %1054 = getelementptr inbounds %struct.inner_cursor, ptr %1053, i32 0, i32 0
  br label %1057

1055:                                             ; preds = %1042
  %1056 = load ptr, ptr %20, align 8, !tbaa !5
  br label %1057

1057:                                             ; preds = %1055, %1050
  %1058 = phi ptr [ %1054, %1050 ], [ %1056, %1055 ]
  store ptr %1058, ptr %21, align 8, !tbaa !5
  %1059 = load i64, ptr %19, align 8, !tbaa !31
  %1060 = load ptr, ptr %21, align 8, !tbaa !5
  %1061 = getelementptr inbounds %struct.MDBX_cursor, ptr %1060, i32 0, i32 1
  %1062 = getelementptr inbounds %struct.anon, ptr %1061, i32 0, i32 1
  %1063 = load i8, ptr %1062, align 1, !tbaa !11
  %1064 = sext i8 %1063 to i64
  %1065 = icmp sgt i64 %1059, %1064
  br i1 %1065, label %1074, label %1066

1066:                                             ; preds = %1057
  %1067 = load ptr, ptr %21, align 8, !tbaa !5
  %1068 = getelementptr inbounds %struct.MDBX_cursor, ptr %1067, i32 0, i32 9
  %1069 = load i64, ptr %19, align 8, !tbaa !31
  %1070 = getelementptr inbounds [32 x ptr], ptr %1068, i64 0, i64 %1069
  %1071 = load ptr, ptr %1070, align 8, !tbaa !5
  %1072 = load ptr, ptr %8, align 8, !tbaa !5
  %1073 = icmp ne ptr %1071, %1072
  br i1 %1073, label %1074, label %1075

1074:                                             ; preds = %1066, %1057
  store i32 46, ptr %7, align 4
  br label %1277

1075:                                             ; preds = %1066
  %1076 = load ptr, ptr %21, align 8, !tbaa !5
  %1077 = getelementptr inbounds %struct.MDBX_cursor, ptr %1076, i32 0, i32 10
  %1078 = load i64, ptr %19, align 8, !tbaa !31
  %1079 = getelementptr inbounds [32 x i16], ptr %1077, i64 0, i64 %1078
  %1080 = load i16, ptr %1079, align 2, !tbaa !24
  %1081 = zext i16 %1080 to i64
  %1082 = load i64, ptr %18, align 8, !tbaa !31
  %1083 = icmp uge i64 %1081, %1082
  br i1 %1083, label %1084, label %1101

1084:                                             ; preds = %1075
  %1085 = load ptr, ptr %21, align 8, !tbaa !5
  %1086 = call i32 @cursor_sibling_right(ptr noundef %1085) #12
  store i32 %1086, ptr %6, align 4, !tbaa !9
  %1087 = load i32, ptr %6, align 4, !tbaa !9
  %1088 = icmp eq i32 %1087, -30798
  br i1 %1088, label %1089, label %1090

1089:                                             ; preds = %1084
  store i32 0, ptr %6, align 4, !tbaa !9
  store i32 46, ptr %7, align 4
  br label %1277

1090:                                             ; preds = %1084
  %1091 = load i32, ptr %6, align 4, !tbaa !9
  %1092 = icmp ne i32 %1091, 0
  %1093 = xor i1 %1092, true
  %1094 = xor i1 %1093, true
  %1095 = zext i1 %1094 to i32
  %1096 = sext i32 %1095 to i64
  %1097 = call i64 @llvm.expect.i64(i64 %1096, i64 0)
  %1098 = icmp ne i64 %1097, 0
  br i1 %1098, label %1099, label %1100

1099:                                             ; preds = %1090
  store i32 20, ptr %7, align 4
  br label %1277

1100:                                             ; preds = %1090
  br label %1101

1101:                                             ; preds = %1100, %1075
  %1102 = load ptr, ptr %21, align 8, !tbaa !5
  %1103 = call zeroext i1 @is_filled(ptr noundef %1102) #10
  br i1 %1103, label %1104, label %1276

1104:                                             ; preds = %1101
  %1105 = load ptr, ptr %21, align 8, !tbaa !5
  %1106 = getelementptr inbounds %struct.MDBX_cursor, ptr %1105, i32 0, i32 8
  %1107 = load ptr, ptr %1106, align 8, !tbaa !25
  %1108 = icmp ne ptr %1107, null
  br i1 %1108, label %1109, label %1276

1109:                                             ; preds = %1104
  %1110 = load ptr, ptr %21, align 8, !tbaa !5
  %1111 = getelementptr inbounds %struct.MDBX_cursor, ptr %1110, i32 0, i32 10
  %1112 = load i64, ptr %19, align 8, !tbaa !31
  %1113 = getelementptr inbounds [32 x i16], ptr %1111, i64 0, i64 %1112
  %1114 = load i16, ptr %1113, align 2, !tbaa !24
  %1115 = zext i16 %1114 to i32
  %1116 = load i16, ptr %15, align 2, !tbaa !24
  %1117 = zext i16 %1116 to i32
  %1118 = icmp sge i32 %1115, %1117
  br i1 %1118, label %1127, label %1119

1119:                                             ; preds = %1109
  %1120 = load ptr, ptr %21, align 8, !tbaa !5
  %1121 = getelementptr inbounds %struct.MDBX_cursor, ptr %1120, i32 0, i32 9
  %1122 = load i64, ptr %19, align 8, !tbaa !31
  %1123 = getelementptr inbounds [32 x ptr], ptr %1121, i64 0, i64 %1122
  %1124 = load ptr, ptr %1123, align 8, !tbaa !5
  %1125 = load ptr, ptr %8, align 8, !tbaa !5
  %1126 = icmp ne ptr %1124, %1125
  br i1 %1126, label %1127, label %1276

1127:                                             ; preds = %1119, %1109
  %1128 = load ptr, ptr %21, align 8, !tbaa !5
  %1129 = getelementptr inbounds %struct.MDBX_cursor, ptr %1128, i32 0, i32 9
  %1130 = load ptr, ptr %21, align 8, !tbaa !5
  %1131 = getelementptr inbounds %struct.MDBX_cursor, ptr %1130, i32 0, i32 1
  %1132 = getelementptr inbounds %struct.anon, ptr %1131, i32 0, i32 1
  %1133 = load i8, ptr %1132, align 1, !tbaa !11
  %1134 = sext i8 %1133 to i64
  %1135 = getelementptr inbounds [32 x ptr], ptr %1129, i64 0, i64 %1134
  %1136 = load ptr, ptr %1135, align 8, !tbaa !5
  %1137 = load ptr, ptr %21, align 8, !tbaa !5
  %1138 = getelementptr inbounds %struct.MDBX_cursor, ptr %1137, i32 0, i32 10
  %1139 = load ptr, ptr %21, align 8, !tbaa !5
  %1140 = getelementptr inbounds %struct.MDBX_cursor, ptr %1139, i32 0, i32 1
  %1141 = getelementptr inbounds %struct.anon, ptr %1140, i32 0, i32 1
  %1142 = load i8, ptr %1141, align 1, !tbaa !11
  %1143 = sext i8 %1142 to i64
  %1144 = getelementptr inbounds [32 x i16], ptr %1138, i64 0, i64 %1143
  %1145 = load i16, ptr %1144, align 2, !tbaa !24
  %1146 = zext i16 %1145 to i64
  %1147 = call ptr @page_node(ptr noundef %1136, i64 noundef %1146) #10
  store ptr %1147, ptr %9, align 8, !tbaa !5
  %1148 = load ptr, ptr %9, align 8, !tbaa !5
  %1149 = call zeroext i8 @node_flags(ptr noundef %1148) #10
  %1150 = zext i8 %1149 to i32
  %1151 = and i32 %1150, 4
  %1152 = icmp ne i32 %1151, 0
  br i1 %1152, label %1153, label %1273

1153:                                             ; preds = %1127
  %1154 = load ptr, ptr %21, align 8, !tbaa !5
  %1155 = getelementptr inbounds %struct.MDBX_cursor, ptr %1154, i32 0, i32 8
  %1156 = load ptr, ptr %1155, align 8, !tbaa !25
  %1157 = getelementptr inbounds %struct.inner_cursor, ptr %1156, i32 0, i32 0
  %1158 = call zeroext i1 @is_pointed(ptr noundef %1157) #10
  br i1 %1158, label %1159, label %1227

1159:                                             ; preds = %1153
  %1160 = load ptr, ptr %9, align 8, !tbaa !5
  %1161 = call zeroext i8 @node_flags(ptr noundef %1160) #10
  %1162 = zext i8 %1161 to i32
  %1163 = and i32 %1162, 2
  %1164 = icmp eq i32 %1163, 0
  br i1 %1164, label %1165, label %1226

1165:                                             ; preds = %1159
  br label %1166

1166:                                             ; preds = %1165
  %1167 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %1168 = zext i8 %1167 to i32
  %1169 = and i32 %1168, 1
  %1170 = icmp ne i32 %1169, 0
  %1171 = xor i1 %1170, true
  %1172 = xor i1 %1171, true
  %1173 = zext i1 %1172 to i32
  %1174 = sext i32 %1173 to i64
  %1175 = call i64 @llvm.expect.i64(i64 %1174, i64 1)
  %1176 = icmp ne i64 %1175, 0
  br i1 %1176, label %1177, label %1215

1177:                                             ; preds = %1166
  br label %1178

1178:                                             ; preds = %1177
  %1179 = load ptr, ptr %21, align 8, !tbaa !5
  %1180 = getelementptr inbounds %struct.MDBX_cursor, ptr %1179, i32 0, i32 8
  %1181 = load ptr, ptr %1180, align 8, !tbaa !25
  %1182 = getelementptr inbounds %struct.inner_cursor, ptr %1181, i32 0, i32 0
  %1183 = getelementptr inbounds %struct.MDBX_cursor, ptr %1182, i32 0, i32 1
  %1184 = getelementptr inbounds %struct.anon, ptr %1183, i32 0, i32 1
  %1185 = load i8, ptr %1184, align 1, !tbaa !11
  %1186 = sext i8 %1185 to i32
  %1187 = icmp eq i32 %1186, 0
  br i1 %1187, label %1188, label %1197

1188:                                             ; preds = %1178
  %1189 = load ptr, ptr %21, align 8, !tbaa !5
  %1190 = getelementptr inbounds %struct.MDBX_cursor, ptr %1189, i32 0, i32 8
  %1191 = load ptr, ptr %1190, align 8, !tbaa !25
  %1192 = getelementptr inbounds %struct.inner_cursor, ptr %1191, i32 0, i32 1
  %1193 = getelementptr inbounds %struct.tree, ptr %1192, i32 0, i32 1
  %1194 = load i16, ptr %1193, align 2, !tbaa !47
  %1195 = zext i16 %1194 to i32
  %1196 = icmp eq i32 %1195, 1
  br label %1197

1197:                                             ; preds = %1188, %1178
  %1198 = phi i1 [ false, %1178 ], [ %1196, %1188 ]
  %1199 = xor i1 %1198, true
  %1200 = xor i1 %1199, true
  %1201 = xor i1 %1200, true
  %1202 = zext i1 %1201 to i32
  %1203 = sext i32 %1202 to i64
  %1204 = call i64 @llvm.expect.i64(i64 %1203, i64 0)
  %1205 = icmp ne i64 %1204, 0
  br i1 %1205, label %1206, label %1212

1206:                                             ; preds = %1197
  %1207 = load ptr, ptr %21, align 8, !tbaa !5
  %1208 = getelementptr inbounds %struct.MDBX_cursor, ptr %1207, i32 0, i32 5
  %1209 = load ptr, ptr %1208, align 8, !tbaa !16
  %1210 = getelementptr inbounds %struct.MDBX_txn, ptr %1209, i32 0, i32 9
  %1211 = load ptr, ptr %1210, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %1211, ptr noundef @.str.104, ptr noundef @__func__.cursor_del, i32 noundef 1694) #13
  unreachable

1212:                                             ; preds = %1197
  br label %1213

1213:                                             ; preds = %1212
  br label %1214

1214:                                             ; preds = %1213
  br label %1215

1215:                                             ; preds = %1214, %1166
  br label %1216

1216:                                             ; preds = %1215
  br label %1217

1217:                                             ; preds = %1216
  %1218 = load ptr, ptr %9, align 8, !tbaa !5
  %1219 = call ptr @node_data(ptr noundef %1218) #10
  %1220 = load ptr, ptr %21, align 8, !tbaa !5
  %1221 = getelementptr inbounds %struct.MDBX_cursor, ptr %1220, i32 0, i32 8
  %1222 = load ptr, ptr %1221, align 8, !tbaa !25
  %1223 = getelementptr inbounds %struct.inner_cursor, ptr %1222, i32 0, i32 0
  %1224 = getelementptr inbounds %struct.MDBX_cursor, ptr %1223, i32 0, i32 9
  %1225 = getelementptr inbounds [32 x ptr], ptr %1224, i64 0, i64 0
  store ptr %1219, ptr %1225, align 8, !tbaa !5
  br label %1226

1226:                                             ; preds = %1217, %1159
  br label %1272

1227:                                             ; preds = %1153
  %1228 = load ptr, ptr %21, align 8, !tbaa !5
  %1229 = load ptr, ptr %9, align 8, !tbaa !5
  %1230 = load ptr, ptr %21, align 8, !tbaa !5
  %1231 = getelementptr inbounds %struct.MDBX_cursor, ptr %1230, i32 0, i32 9
  %1232 = load ptr, ptr %21, align 8, !tbaa !5
  %1233 = getelementptr inbounds %struct.MDBX_cursor, ptr %1232, i32 0, i32 1
  %1234 = getelementptr inbounds %struct.anon, ptr %1233, i32 0, i32 1
  %1235 = load i8, ptr %1234, align 1, !tbaa !11
  %1236 = sext i8 %1235 to i64
  %1237 = getelementptr inbounds [32 x ptr], ptr %1231, i64 0, i64 %1236
  %1238 = load ptr, ptr %1237, align 8, !tbaa !5
  %1239 = call i32 @cursor_dupsort_setup(ptr noundef %1228, ptr noundef %1229, ptr noundef %1238)
  store i32 %1239, ptr %6, align 4, !tbaa !9
  %1240 = load i32, ptr %6, align 4, !tbaa !9
  %1241 = icmp ne i32 %1240, 0
  %1242 = xor i1 %1241, true
  %1243 = xor i1 %1242, true
  %1244 = zext i1 %1243 to i32
  %1245 = sext i32 %1244 to i64
  %1246 = call i64 @llvm.expect.i64(i64 %1245, i64 0)
  %1247 = icmp ne i64 %1246, 0
  br i1 %1247, label %1248, label %1249

1248:                                             ; preds = %1227
  store i32 20, ptr %7, align 4
  br label %1277

1249:                                             ; preds = %1227
  %1250 = load ptr, ptr %9, align 8, !tbaa !5
  %1251 = call zeroext i8 @node_flags(ptr noundef %1250) #10
  %1252 = zext i8 %1251 to i32
  %1253 = and i32 %1252, 2
  %1254 = icmp ne i32 %1253, 0
  br i1 %1254, label %1255, label %1271

1255:                                             ; preds = %1249
  %1256 = load ptr, ptr %21, align 8, !tbaa !5
  %1257 = getelementptr inbounds %struct.MDBX_cursor, ptr %1256, i32 0, i32 8
  %1258 = load ptr, ptr %1257, align 8, !tbaa !25
  %1259 = getelementptr inbounds %struct.inner_cursor, ptr %1258, i32 0, i32 0
  %1260 = call i32 @inner_first(ptr noundef %1259, ptr noundef null) #12
  store i32 %1260, ptr %6, align 4, !tbaa !9
  %1261 = load i32, ptr %6, align 4, !tbaa !9
  %1262 = icmp ne i32 %1261, 0
  %1263 = xor i1 %1262, true
  %1264 = xor i1 %1263, true
  %1265 = zext i1 %1264 to i32
  %1266 = sext i32 %1265 to i64
  %1267 = call i64 @llvm.expect.i64(i64 %1266, i64 0)
  %1268 = icmp ne i64 %1267, 0
  br i1 %1268, label %1269, label %1270

1269:                                             ; preds = %1255
  store i32 20, ptr %7, align 4
  br label %1277

1270:                                             ; preds = %1255
  br label %1271

1271:                                             ; preds = %1270, %1249
  br label %1272

1272:                                             ; preds = %1271, %1226
  br label %1275

1273:                                             ; preds = %1127
  %1274 = load ptr, ptr %21, align 8, !tbaa !5
  call void @inner_gone(ptr noundef %1274)
  br label %1275

1275:                                             ; preds = %1273, %1272
  br label %1276

1276:                                             ; preds = %1275, %1119, %1104, %1101
  store i32 0, ptr %7, align 4
  br label %1277

1277:                                             ; preds = %1276, %1269, %1248, %1099, %1089, %1074
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #11
  %1278 = load i32, ptr %7, align 4
  switch i32 %1278, label %1284 [
    i32 0, label %1279
    i32 46, label %1280
  ]

1279:                                             ; preds = %1277
  br label %1280

1280:                                             ; preds = %1279, %1277
  %1281 = load ptr, ptr %20, align 8, !tbaa !5
  %1282 = getelementptr inbounds %struct.MDBX_cursor, ptr %1281, i32 0, i32 11
  %1283 = load ptr, ptr %1282, align 8, !tbaa !36
  store ptr %1283, ptr %20, align 8, !tbaa !5
  br label %1038, !llvm.loop !48

1284:                                             ; preds = %1277, %1041
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #11
  %1285 = load i32, ptr %7, align 4
  switch i32 %1285, label %1344 [
    i32 44, label %1286
    i32 20, label %1336
  ]

1286:                                             ; preds = %1284
  br label %1287

1287:                                             ; preds = %1286
  %1288 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %1289 = zext i8 %1288 to i32
  %1290 = and i32 %1289, 1
  %1291 = icmp ne i32 %1290, 0
  %1292 = xor i1 %1291, true
  %1293 = xor i1 %1292, true
  %1294 = zext i1 %1293 to i32
  %1295 = sext i32 %1294 to i64
  %1296 = call i64 @llvm.expect.i64(i64 %1295, i64 1)
  %1297 = icmp ne i64 %1296, 0
  br i1 %1297, label %1298, label %1318

1298:                                             ; preds = %1287
  br label %1299

1299:                                             ; preds = %1298
  %1300 = load i32, ptr %6, align 4, !tbaa !9
  %1301 = icmp eq i32 %1300, 0
  %1302 = xor i1 %1301, true
  %1303 = xor i1 %1302, true
  %1304 = xor i1 %1303, true
  %1305 = zext i1 %1304 to i32
  %1306 = sext i32 %1305 to i64
  %1307 = call i64 @llvm.expect.i64(i64 %1306, i64 0)
  %1308 = icmp ne i64 %1307, 0
  br i1 %1308, label %1309, label %1315

1309:                                             ; preds = %1299
  %1310 = load ptr, ptr %4, align 8, !tbaa !5
  %1311 = getelementptr inbounds %struct.MDBX_cursor, ptr %1310, i32 0, i32 5
  %1312 = load ptr, ptr %1311, align 8, !tbaa !16
  %1313 = getelementptr inbounds %struct.MDBX_txn, ptr %1312, i32 0, i32 9
  %1314 = load ptr, ptr %1313, align 8, !tbaa !18
  call void @mdbx_assert_fail(ptr noundef %1314, ptr noundef @.str.47, ptr noundef @__func__.cursor_del, i32 noundef 1712) #13
  unreachable

1315:                                             ; preds = %1299
  br label %1316

1316:                                             ; preds = %1315
  br label %1317

1317:                                             ; preds = %1316
  br label %1318

1318:                                             ; preds = %1317, %1287
  br label %1319

1319:                                             ; preds = %1318
  br label %1320

1320:                                             ; preds = %1319
  %1321 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !12
  %1322 = zext i8 %1321 to i32
  %1323 = and i32 %1322, 2
  %1324 = icmp ne i32 %1323, 0
  %1325 = xor i1 %1324, true
  %1326 = xor i1 %1325, true
  %1327 = zext i1 %1326 to i32
  %1328 = sext i32 %1327 to i64
  %1329 = call i64 @llvm.expect.i64(i64 %1328, i64 0)
  %1330 = icmp ne i64 %1329, 0
  br i1 %1330, label %1331, label %1334

1331:                                             ; preds = %1320
  %1332 = load ptr, ptr %4, align 8, !tbaa !5
  %1333 = call i32 @cursor_validate(ptr noundef %1332) #14
  store i32 %1333, ptr %6, align 4, !tbaa !9
  br label %1334

1334:                                             ; preds = %1331, %1320
  %1335 = load i32, ptr %6, align 4, !tbaa !9
  store i32 %1335, ptr %3, align 4
  store i32 1, ptr %7, align 4
  br label %1344

1336:                                             ; preds = %1284, %811, %599, %507
  %1337 = load ptr, ptr %4, align 8, !tbaa !5
  %1338 = getelementptr inbounds %struct.MDBX_cursor, ptr %1337, i32 0, i32 5
  %1339 = load ptr, ptr %1338, align 8, !tbaa !16
  %1340 = getelementptr inbounds %struct.MDBX_txn, ptr %1339, i32 0, i32 1
  %1341 = load i32, ptr %1340, align 4, !tbaa !49
  %1342 = or i32 %1341, 2
  store i32 %1342, ptr %1340, align 4, !tbaa !49
  %1343 = load i32, ptr %6, align 4, !tbaa !9
  store i32 %1343, ptr %3, align 4
  store i32 1, ptr %7, align 4
  br label %1344

1344:                                             ; preds = %1336, %1334, %1284, %897, %599, %560, %473, %233, %123
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #11
  br label %1345

1345:                                             ; preds = %1344, %43
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #11
  br label %1346

1346:                                             ; preds = %1345, %31
  %1347 = load i32, ptr %3, align 4
  ret i32 %1347

1348:                                             ; preds = %793, %404
  unreachable
}

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_dupfix_leaf(ptr noundef) #3

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i32 @node_largedata_pgno(ptr noalias noundef) #3

declare { ptr, i32 } @page_get_large(ptr noundef, i32 noundef, i64 noundef) #8

; Function Attrs: inlinehint nounwind uwtable
declare hidden i32 @page_retire(ptr noundef, ptr noundef) #9

declare void @node_del(ptr noundef, i64 noundef) #8

; Function Attrs: inlinehint nounwind uwtable
declare hidden zeroext i1 @is_related(ptr noundef, ptr noundef) #9

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @cursor_inner_refresh(ptr noundef, ptr noundef, i32 noundef) #9

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @check_leaf_type(ptr noundef, ptr noundef) #3

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_subpage(ptr noundef) #3

declare ptr @node_shrink(ptr noundef, i64 noundef, ptr noundef) #8

declare i32 @tree_drop(ptr noundef, i1 noundef zeroext) #8

declare i32 @tree_rebalance(ptr noundef) #8

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_inner(ptr noundef) #3

attributes #0 = { cold nounwind optsize 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 #1 = { nocallback nofree nosync nounwind willreturn memory(none) }
attributes #2 = { 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 #3 = { inlinehint nounwind willreturn memory(read) 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 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { 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 #6 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #7 = { 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 #8 = { "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 #9 = { inlinehint 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 #10 = { nounwind willreturn memory(read) }
attributes #11 = { nounwind }
attributes #12 = { hot }
attributes #13 = { noreturn }
attributes #14 = { cold }

!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, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!7, !7, i64 0}
!12 = !{!13, !7, i64 25}
!13 = !{!"libmdbx_globals", !7, i64 0, !10, i64 16, !10, i64 20, !7, i64 24, !7, i64 25, !7, i64 26, !14, i64 27, !10, i64 28, !7, i64 32, !7, i64 40, !15, i64 80, !6, i64 88}
!14 = !{!"_Bool", !7, i64 0}
!15 = !{!"long", !7, i64 0}
!16 = !{!17, !6, i64 16}
!17 = !{!"MDBX_cursor", !10, i64 0, !7, i64 4, !7, i64 6, !7, i64 7, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !7, i64 48, !7, i64 304, !6, i64 368, !6, i64 376}
!18 = !{!19, !6, i64 80}
!19 = !{!"MDBX_txn", !10, i64 0, !10, i64 4, !15, i64 8, !15, i64 16, !6, i64 24, !6, i64 32, !20, i64 40, !15, i64 64, !15, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112, !6, i64 120, !22, i64 128, !6, i64 160, !7, i64 168}
!20 = !{!"geo", !21, i64 0, !21, i64 2, !10, i64 4, !10, i64 8, !7, i64 12, !7, i64 16}
!21 = !{!"short", !7, i64 0}
!22 = !{!"MDBX_canary", !15, i64 0, !15, i64 8, !15, i64 16, !15, i64 24}
!23 = !{!13, !7, i64 26}
!24 = !{!21, !21, i64 0}
!25 = !{!17, !6, i64 40}
!26 = !{!27, !15, i64 416}
!27 = !{!"inner_cursor", !17, i64 0, !28, i64 384}
!28 = !{!"tree", !21, i64 0, !21, i64 2, !10, i64 4, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !15, i64 24, !15, i64 32, !15, i64 40}
!29 = !{!17, !6, i64 24}
!30 = !{!28, !15, i64 32}
!31 = !{!15, !15, i64 0}
!32 = !{!19, !15, i64 64}
!33 = !{!27, !15, i64 424}
!34 = !{!19, !6, i64 120}
!35 = !{!27, !10, i64 392}
!36 = !{!17, !6, i64 368}
!37 = distinct !{!37, !38}
!38 = !{!"llvm.loop.mustprogress"}
!39 = !{!28, !21, i64 2}
!40 = !{!28, !10, i64 8}
!41 = !{!27, !6, i64 24}
!42 = !{!43, !10, i64 8}
!43 = !{!"page_get_result", !6, i64 0, !10, i64 8}
!44 = !{!43, !6, i64 0}
!45 = !{!28, !10, i64 4}
!46 = distinct !{!46, !38}
!47 = !{!27, !21, i64 386}
!48 = distinct !{!48, !38}
!49 = !{!19, !10, i64 4}


; 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.8 }
%struct.anon.8 = 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 }

@globals = external local_unnamed_addr global %struct.libmdbx_globals, align 8
@.str.95 = external hidden unnamed_addr constant [26 x i8], align 1
@__func__.cursor_del = external hidden unnamed_addr constant [11 x i8], align 1
@.str.96 = external hidden unnamed_addr constant [51 x i8], align 1
@.str.97 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.98 = external hidden unnamed_addr constant [78 x i8], align 1
@.str.99 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.100 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.101 = external hidden unnamed_addr constant [111 x i8], align 1
@.str.102 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.103 = external hidden unnamed_addr constant [100 x i8], align 1
@.str.104 = external hidden unnamed_addr constant [67 x i8], align 1

; Function Attrs: cold nounwind optsize uwtable
declare dso_local i32 @cursor_validate(ptr noundef) local_unnamed_addr #0

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

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_pointed(ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @page_numkeys(ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @inner_pointed(ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_filled(ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden ptr @page_node(ptr noundef, i64 noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i8 @node_flags(ptr noalias noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_leaf(ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @cursor_dbi(ptr noundef) local_unnamed_addr #2

; Function Attrs: hot nounwind uwtable
declare dso_local i32 @cursor_touch(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_modifable(ptr noundef, ptr 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) #4

; Function Attrs: nounwind uwtable
declare dso_local i32 @cursor_dupsort_setup(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #5

declare void @debug_log(i32 noundef, ptr noundef, i32 noundef, ptr noundef, ...) local_unnamed_addr #6

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden ptr @node_data(ptr noalias noundef) local_unnamed_addr #2

; Function Attrs: hot nounwind uwtable
declare dso_local i32 @cursor_sibling_right(ptr noundef) local_unnamed_addr #3

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @inner_gone(ptr noundef) local_unnamed_addr #7

; Function Attrs: hot nounwind uwtable
declare dso_local i32 @inner_first(ptr noundef, ptr noundef) local_unnamed_addr #3

; Function Attrs: hot nounwind uwtable
define dso_local i32 @cursor_del(ptr noundef %0, i32 noundef %1) local_unnamed_addr #3 {
  %3 = tail call zeroext i1 @is_filled(ptr noundef %0) #8
  br i1 %3, label %4, label %408, !prof !5

4:                                                ; preds = %2
  %5 = tail call i32 @cursor_touch(ptr noundef %0, ptr noundef null, ptr noundef null) #9
  %.not = icmp eq i32 %5, 0
  br i1 %.not, label %6, label %408, !prof !5

6:                                                ; preds = %4
  %7 = getelementptr inbounds i8, ptr %0, i64 48
  %8 = getelementptr inbounds i8, ptr %0, i64 4
  %9 = getelementptr inbounds i8, ptr %0, i64 5
  %10 = load i8, ptr %9, align 1, !tbaa !6
  %11 = sext i8 %10 to i64
  %12 = getelementptr inbounds [32 x ptr], ptr %7, i64 0, i64 %11
  %13 = load ptr, ptr %12, align 8, !tbaa !9
  %14 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !11
  %15 = and i8 %14, 1
  %.not240 = icmp eq i8 %15, 0
  br i1 %.not240, label %23, label %16, !prof !16

16:                                               ; preds = %6
  %17 = getelementptr inbounds i8, ptr %0, i64 16
  %18 = load ptr, ptr %17, align 8, !tbaa !17
  %19 = tail call zeroext i1 @is_modifable(ptr noundef %18, ptr noundef %13) #8
  br i1 %19, label %23, label %20, !prof !5

20:                                               ; preds = %16
  %21 = getelementptr inbounds i8, ptr %18, i64 80
  %22 = load ptr, ptr %21, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %22, ptr noundef nonnull @.str.95, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1533) #10
  unreachable

23:                                               ; preds = %16, %6
  %24 = tail call zeroext i1 @check_leaf_type(ptr noundef nonnull %0, ptr noundef %13) #8
  br i1 %24, label %33, label %25, !prof !5

25:                                               ; preds = %23
  %26 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !24
  %.not289 = icmp eq i8 %26, 0
  br i1 %.not289, label %408, label %27, !prof !5

27:                                               ; preds = %25
  %28 = getelementptr inbounds i8, ptr %13, i64 16
  %29 = load i32, ptr %28, align 1, !tbaa !25
  %30 = getelementptr inbounds i8, ptr %13, i64 10
  %31 = load i16, ptr %30, align 1, !tbaa !26
  %32 = zext i16 %31 to i32
  tail call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 1, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1535, ptr noundef nonnull @.str.96, i32 noundef %29, i32 noundef %32) #11
  br label %408

33:                                               ; preds = %23
  %34 = tail call zeroext i1 @is_dupfix_leaf(ptr noundef %13) #8
  br i1 %34, label %193, label %35

35:                                               ; preds = %33
  %36 = getelementptr inbounds i8, ptr %0, i64 304
  %37 = getelementptr inbounds [32 x i16], ptr %36, i64 0, i64 %11
  %38 = load i16, ptr %37, align 2, !tbaa !26
  %39 = zext i16 %38 to i64
  %40 = tail call ptr @page_node(ptr noundef %13, i64 noundef %39) #8
  %41 = tail call zeroext i8 @node_flags(ptr noundef %40) #8
  %42 = zext i8 %41 to i32
  %43 = and i32 %42, 4
  %.not241 = icmp eq i32 %43, 0
  br i1 %.not241, label %171, label %44

44:                                               ; preds = %35
  %45 = and i32 %1, 160
  %.not244 = icmp eq i32 %45, 0
  br i1 %.not244, label %56, label %46

46:                                               ; preds = %44
  %47 = getelementptr inbounds i8, ptr %0, i64 40
  %48 = load ptr, ptr %47, align 8, !tbaa !27
  %49 = getelementptr inbounds i8, ptr %48, i64 416
  %50 = load i64, ptr %49, align 8, !tbaa !28
  %51 = getelementptr inbounds i8, ptr %0, i64 24
  %52 = load ptr, ptr %51, align 8, !tbaa !31
  %53 = getelementptr inbounds i8, ptr %52, i64 32
  %54 = load i64, ptr %53, align 4, !tbaa !32
  %reass.sub = sub i64 %54, %50
  %55 = add i64 %reass.sub, 1
  store i64 %55, ptr %53, align 4, !tbaa !32
  br label %159

56:                                               ; preds = %44
  %57 = and i32 %42, 2
  %.not245 = icmp eq i32 %57, 0
  br i1 %.not245, label %58, label %72

58:                                               ; preds = %56
  %59 = tail call ptr @node_data(ptr noundef %40) #8
  br i1 %.not240, label %67, label %60, !prof !16

60:                                               ; preds = %58
  %61 = tail call zeroext i1 @is_subpage(ptr noundef %59) #8
  br i1 %61, label %67, label %62, !prof !5

62:                                               ; preds = %60
  %63 = getelementptr inbounds i8, ptr %0, i64 16
  %64 = load ptr, ptr %63, align 8, !tbaa !17
  %65 = getelementptr inbounds i8, ptr %64, i64 80
  %66 = load ptr, ptr %65, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %66, ptr noundef nonnull @.str.97, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1549) #10
  unreachable

67:                                               ; preds = %60, %58
  %68 = load i64, ptr %13, align 1, !tbaa !33
  store i64 %68, ptr %59, align 1, !tbaa !33
  %69 = getelementptr inbounds i8, ptr %0, i64 40
  %70 = load ptr, ptr %69, align 8, !tbaa !27
  %71 = getelementptr inbounds i8, ptr %70, i64 48
  store ptr %59, ptr %71, align 8, !tbaa !9
  br label %72

72:                                               ; preds = %67, %56
  %73 = getelementptr inbounds i8, ptr %0, i64 40
  %74 = load ptr, ptr %73, align 8, !tbaa !27
  %75 = tail call i32 @cursor_del(ptr noundef %74, i32 noundef 0) #9
  %.not247 = icmp eq i32 %75, 0
  br i1 %.not247, label %76, label %408, !prof !5

76:                                               ; preds = %72
  %77 = load ptr, ptr %73, align 8, !tbaa !27
  %78 = getelementptr inbounds i8, ptr %77, i64 416
  %79 = load i64, ptr %78, align 8, !tbaa !28
  %.not248 = icmp eq i64 %79, 0
  br i1 %.not248, label %159, label %80

80:                                               ; preds = %76
  %81 = tail call zeroext i8 @node_flags(ptr noundef %40) #8
  %82 = and i8 %81, 2
  %.not249 = icmp eq i8 %82, 0
  br i1 %.not249, label %91, label %83

83:                                               ; preds = %80
  %84 = getelementptr inbounds i8, ptr %0, i64 16
  %85 = load ptr, ptr %84, align 8, !tbaa !17
  %86 = getelementptr inbounds i8, ptr %85, i64 64
  %87 = load i64, ptr %86, align 8, !tbaa !34
  %88 = getelementptr inbounds i8, ptr %77, i64 424
  store i64 %87, ptr %88, align 8, !tbaa !35
  %89 = tail call ptr @node_data(ptr noundef %40) #8
  %90 = getelementptr inbounds i8, ptr %77, i64 384
  tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(48) %89, ptr noundef nonnull align 8 dereferenceable(48) %90, i64 48, i1 false)
  br label %.loopexit

91:                                               ; preds = %80
  %92 = load i8, ptr %9, align 1, !tbaa !6
  %93 = sext i8 %92 to i64
  %94 = getelementptr inbounds [32 x i16], ptr %36, i64 0, i64 %93
  %95 = load i16, ptr %94, align 2, !tbaa !26
  %96 = zext i16 %95 to i64
  %97 = tail call ptr @node_shrink(ptr noundef %13, i64 noundef %96, ptr noundef %40) #11
  %98 = tail call ptr @node_data(ptr noundef %97) #8
  %99 = load ptr, ptr %73, align 8, !tbaa !27
  %100 = getelementptr inbounds i8, ptr %99, i64 48
  store ptr %98, ptr %100, align 8, !tbaa !9
  %101 = getelementptr inbounds i8, ptr %0, i64 16
  %102 = load ptr, ptr %101, align 8, !tbaa !17
  %103 = getelementptr inbounds i8, ptr %102, i64 120
  %104 = load ptr, ptr %103, align 8, !tbaa !36
  %105 = tail call i64 @cursor_dbi(ptr noundef nonnull %0) #8
  %106 = getelementptr inbounds ptr, ptr %104, i64 %105
  %.0219317 = load ptr, ptr %106, align 8, !tbaa !9
  %.not250318 = icmp eq ptr %.0219317, null
  br i1 %.not250318, label %.loopexit, label %.lr.ph

.lr.ph:                                           ; preds = %91, %138
  %.0219319 = phi ptr [ %.0219, %138 ], [ %.0219317, %91 ]
  %107 = tail call zeroext i1 @is_related(ptr noundef %0, ptr noundef nonnull %.0219319)
  br i1 %107, label %108, label %138

108:                                              ; preds = %.lr.ph
  %109 = getelementptr inbounds i8, ptr %.0219319, i64 48
  %110 = load i8, ptr %9, align 1, !tbaa !6
  %111 = sext i8 %110 to i64
  %112 = getelementptr inbounds [32 x ptr], ptr %109, i64 0, i64 %111
  %113 = load ptr, ptr %112, align 8, !tbaa !9
  %.not251 = icmp eq ptr %113, %13
  br i1 %.not251, label %114, label %138

114:                                              ; preds = %108
  %115 = getelementptr inbounds i8, ptr %.0219319, i64 304
  %116 = getelementptr inbounds [32 x i16], ptr %115, i64 0, i64 %111
  %117 = load i16, ptr %116, align 2, !tbaa !26
  %118 = zext i16 %117 to i64
  %119 = tail call i64 @page_numkeys(ptr noundef %13) #8
  %.not252 = icmp ugt i64 %119, %118
  br i1 %.not252, label %126, label %120, !prof !5

120:                                              ; preds = %114
  %121 = getelementptr inbounds i8, ptr %.0219319, i64 4
  store i8 -48, ptr %121, align 4, !tbaa !6
  %122 = getelementptr inbounds i8, ptr %.0219319, i64 40
  %123 = load ptr, ptr %122, align 8, !tbaa !27
  %124 = getelementptr inbounds i8, ptr %123, i64 392
  store i32 0, ptr %124, align 8, !tbaa !37
  %125 = getelementptr inbounds i8, ptr %123, i64 4
  store i16 -47, ptr %125, align 4, !tbaa !6
  br label %138

126:                                              ; preds = %114
  %127 = getelementptr inbounds [32 x i16], ptr %36, i64 0, i64 %111
  %128 = load i16, ptr %127, align 2, !tbaa !26
  %.not253 = icmp eq i16 %117, %128
  br i1 %.not253, label %133, label %129

129:                                              ; preds = %126
  %130 = tail call ptr @page_node(ptr noundef %13, i64 noundef %118) #8
  %131 = tail call zeroext i8 @node_flags(ptr noundef %130) #8
  %132 = and i8 %131, 2
  %.not254 = icmp eq i8 %132, 0
  br i1 %.not254, label %133, label %138

133:                                              ; preds = %129, %126
  %.0220 = phi ptr [ %130, %129 ], [ %97, %126 ]
  %134 = tail call ptr @node_data(ptr noundef %.0220) #8
  %135 = getelementptr inbounds i8, ptr %.0219319, i64 40
  %136 = load ptr, ptr %135, align 8, !tbaa !27
  %137 = getelementptr inbounds i8, ptr %136, i64 48
  store ptr %134, ptr %137, align 8, !tbaa !9
  br label %138

138:                                              ; preds = %120, %133, %129, %.lr.ph, %108
  %139 = getelementptr inbounds i8, ptr %.0219319, i64 368
  %.0219 = load ptr, ptr %139, align 8, !tbaa !9
  %.not250 = icmp eq ptr %.0219, null
  br i1 %.not250, label %.loopexit, label %.lr.ph, !llvm.loop !38

.loopexit:                                        ; preds = %138, %91, %83
  %140 = getelementptr inbounds i8, ptr %0, i64 24
  %141 = load ptr, ptr %140, align 8, !tbaa !31
  %142 = getelementptr inbounds i8, ptr %141, i64 32
  %143 = load i64, ptr %142, align 4, !tbaa !32
  %144 = add i64 %143, -1
  store i64 %144, ptr %142, align 4, !tbaa !32
  %145 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !11
  %146 = and i8 %145, 1
  %.not255 = icmp eq i8 %146, 0
  br i1 %.not255, label %408, label %147, !prof !16

147:                                              ; preds = %.loopexit
  %.not256 = icmp eq i64 %144, 0
  br i1 %.not256, label %.critedge, label %148, !prof !16

148:                                              ; preds = %147
  %149 = getelementptr inbounds i8, ptr %141, i64 2
  %150 = load i16, ptr %149, align 2, !tbaa !40
  %.not257 = icmp eq i16 %150, 0
  br i1 %.not257, label %.critedge, label %151, !prof !16

151:                                              ; preds = %148
  %152 = getelementptr inbounds i8, ptr %141, i64 8
  %153 = load i32, ptr %152, align 4, !tbaa !41
  %154 = icmp eq i32 %153, -1
  br i1 %154, label %.critedge, label %408, !prof !16

.critedge:                                        ; preds = %148, %147, %151
  %155 = getelementptr inbounds i8, ptr %0, i64 16
  %156 = load ptr, ptr %155, align 8, !tbaa !17
  %157 = getelementptr inbounds i8, ptr %156, i64 80
  %158 = load ptr, ptr %157, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %158, ptr noundef nonnull @.str.98, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1586) #10
  unreachable

159:                                              ; preds = %76, %46
  %160 = phi ptr [ %77, %76 ], [ %48, %46 ]
  %161 = tail call zeroext i8 @node_flags(ptr noundef %40) #8
  %162 = and i8 %161, 2
  %.not258 = icmp eq i8 %162, 0
  br i1 %.not258, label %170, label %163

163:                                              ; preds = %159
  %164 = getelementptr inbounds i8, ptr %160, i64 24
  %165 = load ptr, ptr %164, align 8, !tbaa !42
  %166 = getelementptr inbounds i8, ptr %165, i64 2
  %167 = load i16, ptr %166, align 2, !tbaa !40
  %.not259 = icmp eq i16 %167, 0
  br i1 %.not259, label %170, label %168

168:                                              ; preds = %163
  %169 = tail call i32 @tree_drop(ptr noundef nonnull %160, i1 noundef zeroext false) #11
  %.not260 = icmp eq i32 %169, 0
  br i1 %.not260, label %170, label %.thread, !prof !5

170:                                              ; preds = %168, %163, %159
  tail call void @inner_gone(ptr noundef nonnull %0)
  br label %182

171:                                              ; preds = %35
  br i1 %.not240, label %179, label %172, !prof !16

172:                                              ; preds = %171
  %173 = tail call zeroext i1 @inner_pointed(ptr noundef nonnull %0) #8
  br i1 %173, label %174, label %179, !prof !16

174:                                              ; preds = %172
  %175 = getelementptr inbounds i8, ptr %0, i64 16
  %176 = load ptr, ptr %175, align 8, !tbaa !17
  %177 = getelementptr inbounds i8, ptr %176, i64 80
  %178 = load ptr, ptr %177, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %178, ptr noundef nonnull @.str.99, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1600) #10
  unreachable

179:                                              ; preds = %172, %171
  %180 = xor i32 %42, %1
  %181 = and i32 %180, 2
  %.not243 = icmp eq i32 %181, 0
  br i1 %.not243, label %182, label %408, !prof !5

182:                                              ; preds = %179, %170
  %183 = tail call zeroext i8 @node_flags(ptr noundef %40) #8
  %184 = and i8 %183, 1
  %.not261 = icmp eq i8 %184, 0
  br i1 %.not261, label %193, label %185

185:                                              ; preds = %182
  %186 = tail call i32 @node_largedata_pgno(ptr noundef %40) #8
  %187 = load i64, ptr %13, align 1, !tbaa !33
  %188 = tail call { ptr, i32 } @page_get_large(ptr noundef nonnull %0, i32 noundef %186, i64 noundef %187) #11
  %189 = extractvalue { ptr, i32 } %188, 1
  %.not262 = icmp eq i32 %189, 0
  br i1 %.not262, label %190, label %.thread, !prof !5

190:                                              ; preds = %185
  %191 = extractvalue { ptr, i32 } %188, 0
  %192 = tail call i32 @page_retire(ptr noundef nonnull %0, ptr noundef %191)
  %.not313 = icmp eq i32 %192, 0
  br i1 %.not313, label %193, label %.thread

193:                                              ; preds = %190, %182, %33
  %194 = getelementptr inbounds i8, ptr %0, i64 24
  %195 = load ptr, ptr %194, align 8, !tbaa !31
  %196 = getelementptr inbounds i8, ptr %195, i64 32
  %197 = load i64, ptr %196, align 4, !tbaa !32
  %198 = add i64 %197, -1
  store i64 %198, ptr %196, align 4, !tbaa !32
  %199 = tail call i64 @cursor_dbi(ptr noundef nonnull %0) #8
  %200 = getelementptr inbounds i8, ptr %0, i64 304
  %201 = load i8, ptr %9, align 1, !tbaa !6
  %202 = sext i8 %201 to i64
  %203 = getelementptr inbounds [32 x i16], ptr %200, i64 0, i64 %202
  %204 = load i16, ptr %203, align 2, !tbaa !26
  %205 = getelementptr inbounds [32 x ptr], ptr %7, i64 0, i64 %202
  %206 = load ptr, ptr %205, align 8, !tbaa !9
  %207 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !11
  %208 = and i8 %207, 1
  %.not263 = icmp eq i8 %208, 0
  br i1 %.not263, label %216, label %209, !prof !16

209:                                              ; preds = %193
  %210 = tail call zeroext i1 @is_leaf(ptr noundef %206) #8
  br i1 %210, label %216, label %211, !prof !5

211:                                              ; preds = %209
  %212 = getelementptr inbounds i8, ptr %0, i64 16
  %213 = load ptr, ptr %212, align 8, !tbaa !17
  %214 = getelementptr inbounds i8, ptr %213, i64 80
  %215 = load ptr, ptr %214, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %215, ptr noundef nonnull @.str.100, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1618) #10
  unreachable

216:                                              ; preds = %209, %193
  %217 = getelementptr inbounds i8, ptr %195, i64 4
  %218 = load i32, ptr %217, align 4, !tbaa !43
  %219 = zext i32 %218 to i64
  tail call void @node_del(ptr noundef nonnull %0, i64 noundef %219) #11
  %220 = getelementptr inbounds i8, ptr %0, i64 16
  %221 = load ptr, ptr %220, align 8, !tbaa !17
  %222 = getelementptr inbounds i8, ptr %221, i64 120
  %223 = load ptr, ptr %222, align 8, !tbaa !36
  %224 = and i64 %199, 4294967295
  %225 = getelementptr inbounds ptr, ptr %223, i64 %224
  %.0218320 = load ptr, ptr %225, align 8, !tbaa !9
  %.not264321 = icmp eq ptr %.0218320, null
  br i1 %.not264321, label %._crit_edge, label %.lr.ph323

._crit_edge:                                      ; preds = %262, %216
  %226 = tail call i32 @tree_rebalance(ptr noundef nonnull %0) #11
  %.not265 = icmp eq i32 %226, 0
  br i1 %.not265, label %264, label %.thread, !prof !5

.lr.ph323:                                        ; preds = %216, %262
  %.0218322 = phi ptr [ %.0218, %262 ], [ %.0218320, %216 ]
  %227 = load i8, ptr %8, align 4, !tbaa !6
  %228 = and i8 %227, 1
  %.not287 = icmp eq i8 %228, 0
  br i1 %.not287, label %232, label %229

229:                                              ; preds = %.lr.ph323
  %230 = getelementptr inbounds i8, ptr %.0218322, i64 40
  %231 = load ptr, ptr %230, align 8, !tbaa !27
  br label %232

232:                                              ; preds = %.lr.ph323, %229
  %233 = phi ptr [ %231, %229 ], [ %.0218322, %.lr.ph323 ]
  %234 = tail call zeroext i1 @is_related(ptr noundef nonnull %0, ptr noundef %233)
  br i1 %234, label %235, label %262

235:                                              ; preds = %232
  %236 = getelementptr inbounds i8, ptr %233, i64 48
  %237 = load i8, ptr %9, align 1, !tbaa !6
  %238 = sext i8 %237 to i64
  %239 = getelementptr inbounds [32 x ptr], ptr %236, i64 0, i64 %238
  %240 = load ptr, ptr %239, align 8, !tbaa !9
  %.not288 = icmp eq ptr %240, %206
  br i1 %.not288, label %241, label %262

241:                                              ; preds = %235
  %242 = getelementptr inbounds i8, ptr %233, i64 304
  %243 = getelementptr inbounds [32 x i16], ptr %242, i64 0, i64 %238
  %244 = load i16, ptr %243, align 2, !tbaa !26
  %245 = icmp eq i16 %244, %204
  br i1 %245, label %246, label %250

246:                                              ; preds = %241
  %247 = getelementptr inbounds i8, ptr %233, i64 4
  %248 = load i8, ptr %247, align 4, !tbaa !6
  %249 = or i8 %248, 8
  store i8 %249, ptr %247, align 4, !tbaa !6
  tail call void @inner_gone(ptr noundef nonnull %233)
  br label %262

250:                                              ; preds = %241
  %251 = icmp ugt i16 %244, %204
  %.neg = sext i1 %251 to i16
  %252 = add i16 %244, %.neg
  store i16 %252, ptr %243, align 2, !tbaa !26
  %253 = tail call zeroext i1 @inner_pointed(ptr noundef nonnull %233) #8
  br i1 %253, label %254, label %262

254:                                              ; preds = %250
  %255 = load i8, ptr %9, align 1, !tbaa !6
  %256 = sext i8 %255 to i64
  %257 = getelementptr inbounds [32 x ptr], ptr %236, i64 0, i64 %256
  %258 = load ptr, ptr %257, align 8, !tbaa !9
  %259 = getelementptr inbounds [32 x i16], ptr %242, i64 0, i64 %256
  %260 = load i16, ptr %259, align 2, !tbaa !26
  %261 = zext i16 %260 to i32
  tail call void @cursor_inner_refresh(ptr noundef nonnull %233, ptr noundef %258, i32 noundef %261)
  br label %262

262:                                              ; preds = %246, %254, %250, %232, %235
  %263 = getelementptr inbounds i8, ptr %.0218322, i64 368
  %.0218 = load ptr, ptr %263, align 8, !tbaa !9
  %.not264 = icmp eq ptr %.0218, null
  br i1 %.not264, label %._crit_edge, label %.lr.ph323, !llvm.loop !44

264:                                              ; preds = %._crit_edge
  %265 = load i8, ptr %8, align 4, !tbaa !6
  %266 = or i8 %265, 8
  store i8 %266, ptr %8, align 4, !tbaa !6
  tail call void @inner_gone(ptr noundef nonnull %0)
  %267 = load i8, ptr %9, align 1, !tbaa !6
  %268 = icmp slt i8 %267, 0
  br i1 %268, label %269, label %289, !prof !16

269:                                              ; preds = %264
  %270 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !11
  %271 = and i8 %270, 1
  %.not285 = icmp eq i8 %271, 0
  br i1 %.not285, label %408, label %272, !prof !16

272:                                              ; preds = %269
  %273 = load ptr, ptr %194, align 8, !tbaa !31
  %274 = getelementptr inbounds i8, ptr %273, i64 32
  %275 = load i64, ptr %274, align 4, !tbaa !32
  %276 = icmp eq i64 %275, 0
  br i1 %276, label %277, label %.critedge292, !prof !5

277:                                              ; preds = %272
  %278 = getelementptr inbounds i8, ptr %273, i64 8
  %279 = load i32, ptr %278, align 4, !tbaa !41
  %280 = icmp eq i32 %279, -1
  br i1 %280, label %283, label %281

281:                                              ; preds = %277
  %282 = tail call zeroext i1 @is_inner(ptr noundef nonnull %0) #8
  %.not286 = icmp eq i32 %279, 0
  %or.cond290 = and i1 %.not286, %282
  br i1 %or.cond290, label %283, label %.critedge292, !prof !45

283:                                              ; preds = %281, %277
  %284 = load i8, ptr %8, align 4, !tbaa !6
  %285 = icmp sgt i8 %284, -1
  br i1 %285, label %.critedge292, label %408, !prof !16

.critedge292:                                     ; preds = %281, %272, %283
  %286 = load ptr, ptr %220, align 8, !tbaa !17
  %287 = getelementptr inbounds i8, ptr %286, i64 80
  %288 = load ptr, ptr %287, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %288, ptr noundef nonnull @.str.101, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1647) #10
  unreachable

289:                                              ; preds = %264
  %290 = zext nneg i8 %267 to i64
  %291 = getelementptr inbounds [32 x i16], ptr %200, i64 0, i64 %290
  %292 = load i16, ptr %291, align 2, !tbaa !26
  %293 = getelementptr inbounds [32 x ptr], ptr %7, i64 0, i64 %290
  %294 = load ptr, ptr %293, align 8, !tbaa !9
  %295 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !11
  %296 = and i8 %295, 1
  %.not266 = icmp eq i8 %296, 0
  br i1 %.not266, label %.thread304, label %298, !prof !16

.thread304:                                       ; preds = %289
  %297 = tail call i64 @page_numkeys(ptr noundef %294) #8
  br label %.critedge295

298:                                              ; preds = %289
  %299 = tail call zeroext i1 @is_leaf(ptr noundef %294) #8
  br i1 %299, label %304, label %300, !prof !5

300:                                              ; preds = %298
  %301 = load ptr, ptr %220, align 8, !tbaa !17
  %302 = getelementptr inbounds i8, ptr %301, i64 80
  %303 = load ptr, ptr %302, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %303, ptr noundef nonnull @.str.102, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1653) #10
  unreachable

304:                                              ; preds = %298
  %305 = tail call i64 @page_numkeys(ptr noundef %294) #8
  %306 = load ptr, ptr %194, align 8, !tbaa !31
  %307 = getelementptr inbounds i8, ptr %306, i64 32
  %308 = load i64, ptr %307, align 4, !tbaa !32
  %309 = icmp ne i64 %308, 0
  %310 = icmp ne i64 %305, 0
  %or.cond = select i1 %309, i1 %310, i1 false
  br i1 %or.cond, label %.critedge295, label %311

311:                                              ; preds = %304
  %312 = load i8, ptr %8, align 4, !tbaa !6
  %313 = and i8 %312, 1
  %.not268 = icmp ne i8 %313, 0
  %314 = icmp eq i64 %308, 0
  %or.cond293 = and i1 %314, %.not268
  %315 = icmp eq i64 %305, 0
  %or.cond302 = select i1 %or.cond293, i1 %315, i1 false
  br i1 %or.cond302, label %.critedge295, label %.critedge297, !prof !46

.critedge297:                                     ; preds = %311
  %316 = load ptr, ptr %220, align 8, !tbaa !17
  %317 = getelementptr inbounds i8, ptr %316, i64 80
  %318 = load ptr, ptr %317, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %318, ptr noundef nonnull @.str.103, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1655) #10
  unreachable

.critedge295:                                     ; preds = %.thread304, %311, %304
  %319 = phi i64 [ %297, %.thread304 ], [ 0, %311 ], [ %305, %304 ]
  %320 = load ptr, ptr %220, align 8, !tbaa !17
  %321 = getelementptr inbounds i8, ptr %320, i64 120
  %322 = load ptr, ptr %321, align 8, !tbaa !36
  %323 = getelementptr inbounds ptr, ptr %322, i64 %224
  %.0211324 = load ptr, ptr %323, align 8, !tbaa !9
  %.not269325 = icmp eq ptr %.0211324, null
  br i1 %.not269325, label %._crit_edge328, label %.lr.ph327

.lr.ph327:                                        ; preds = %.critedge295, %select.unfold
  %.0211326 = phi ptr [ %.0211, %select.unfold ], [ %.0211324, %.critedge295 ]
  %324 = load i8, ptr %8, align 4, !tbaa !6
  %325 = and i8 %324, 1
  %.not270 = icmp eq i8 %325, 0
  br i1 %.not270, label %329, label %326

326:                                              ; preds = %.lr.ph327
  %327 = getelementptr inbounds i8, ptr %.0211326, i64 40
  %328 = load ptr, ptr %327, align 8, !tbaa !27
  br label %329

329:                                              ; preds = %.lr.ph327, %326
  %330 = phi ptr [ %328, %326 ], [ %.0211326, %.lr.ph327 ]
  %331 = getelementptr inbounds i8, ptr %330, i64 5
  %332 = load i8, ptr %331, align 1, !tbaa !6
  %333 = icmp sgt i8 %267, %332
  br i1 %333, label %select.unfold, label %334

334:                                              ; preds = %329
  %335 = getelementptr inbounds i8, ptr %330, i64 48
  %336 = getelementptr inbounds [32 x ptr], ptr %335, i64 0, i64 %290
  %337 = load ptr, ptr %336, align 8, !tbaa !9
  %.not271 = icmp eq ptr %337, %294
  br i1 %.not271, label %338, label %select.unfold

338:                                              ; preds = %334
  %339 = getelementptr inbounds i8, ptr %330, i64 304
  %340 = getelementptr inbounds [32 x i16], ptr %339, i64 0, i64 %290
  %341 = load i16, ptr %340, align 2, !tbaa !26
  %342 = zext i16 %341 to i64
  %.not272 = icmp ugt i64 %319, %342
  br i1 %.not272, label %345, label %343

343:                                              ; preds = %338
  %344 = tail call i32 @cursor_sibling_right(ptr noundef nonnull %330) #9
  switch i32 %344, label %.thread [
    i32 -30798, label %select.unfold
    i32 0, label %345
  ], !prof !47

345:                                              ; preds = %343, %338
  %346 = tail call zeroext i1 @is_filled(ptr noundef nonnull %330) #8
  br i1 %346, label %347, label %select.unfold

347:                                              ; preds = %345
  %348 = getelementptr inbounds i8, ptr %330, i64 40
  %349 = load ptr, ptr %348, align 8, !tbaa !27
  %.not274 = icmp eq ptr %349, null
  br i1 %.not274, label %select.unfold, label %350

350:                                              ; preds = %347
  %351 = load i16, ptr %340, align 2, !tbaa !26
  %.not275 = icmp ult i16 %351, %292
  br i1 %.not275, label %352, label %354

352:                                              ; preds = %350
  %353 = load ptr, ptr %336, align 8, !tbaa !9
  %.not276 = icmp eq ptr %353, %294
  br i1 %.not276, label %select.unfold, label %354

354:                                              ; preds = %352, %350
  %355 = load i8, ptr %331, align 1, !tbaa !6
  %356 = sext i8 %355 to i64
  %357 = getelementptr inbounds [32 x ptr], ptr %335, i64 0, i64 %356
  %358 = load ptr, ptr %357, align 8, !tbaa !9
  %359 = getelementptr inbounds [32 x i16], ptr %339, i64 0, i64 %356
  %360 = load i16, ptr %359, align 2, !tbaa !26
  %361 = zext i16 %360 to i64
  %362 = tail call ptr @page_node(ptr noundef %358, i64 noundef %361) #8
  %363 = tail call zeroext i8 @node_flags(ptr noundef %362) #8
  %364 = zext i8 %363 to i32
  %365 = and i32 %364, 4
  %.not277 = icmp eq i32 %365, 0
  br i1 %.not277, label %397, label %366

366:                                              ; preds = %354
  %367 = tail call zeroext i1 @is_pointed(ptr noundef nonnull %349) #8
  br i1 %367, label %368, label %389

368:                                              ; preds = %366
  %369 = and i32 %364, 2
  %370 = icmp eq i32 %369, 0
  br i1 %370, label %371, label %select.unfold

371:                                              ; preds = %368
  %372 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !11
  %373 = and i8 %372, 1
  %.not281 = icmp eq i8 %373, 0
  br i1 %.not281, label %386, label %374, !prof !16

374:                                              ; preds = %371
  %375 = getelementptr inbounds i8, ptr %349, i64 5
  %376 = load i8, ptr %375, align 1, !tbaa !6
  %377 = icmp eq i8 %376, 0
  br i1 %377, label %378, label %.critedge299, !prof !5

378:                                              ; preds = %374
  %379 = getelementptr inbounds i8, ptr %349, i64 386
  %380 = load i16, ptr %379, align 2, !tbaa !48
  %381 = icmp eq i16 %380, 1
  br i1 %381, label %386, label %.critedge299, !prof !5

.critedge299:                                     ; preds = %374, %378
  %382 = getelementptr inbounds i8, ptr %330, i64 16
  %383 = load ptr, ptr %382, align 8, !tbaa !17
  %384 = getelementptr inbounds i8, ptr %383, i64 80
  %385 = load ptr, ptr %384, align 8, !tbaa !19
  tail call void @mdbx_assert_fail(ptr noundef %385, ptr noundef nonnull @.str.104, ptr noundef nonnull @__func__.cursor_del, i32 noundef 1694) #10
  unreachable

386:                                              ; preds = %378, %371
  %387 = tail call ptr @node_data(ptr noundef %362) #8
  %388 = getelementptr inbounds i8, ptr %349, i64 48
  store ptr %387, ptr %388, align 8, !tbaa !9
  br label %select.unfold

389:                                              ; preds = %366
  %390 = tail call i32 @cursor_dupsort_setup(ptr noundef nonnull %330, ptr noundef %362, ptr noundef %358)
  %.not278 = icmp eq i32 %390, 0
  br i1 %.not278, label %391, label %.thread, !prof !5

391:                                              ; preds = %389
  %392 = tail call zeroext i8 @node_flags(ptr noundef %362) #8
  %393 = and i8 %392, 2
  %.not279 = icmp eq i8 %393, 0
  br i1 %.not279, label %select.unfold, label %394

394:                                              ; preds = %391
  %395 = load ptr, ptr %348, align 8, !tbaa !27
  %396 = tail call i32 @inner_first(ptr noundef %395, ptr noundef null) #9
  %.not280 = icmp eq i32 %396, 0
  br i1 %.not280, label %select.unfold, label %.thread, !prof !5

397:                                              ; preds = %354
  tail call void @inner_gone(ptr noundef nonnull %330)
  br label %select.unfold

select.unfold:                                    ; preds = %394, %334, %329, %343, %397, %391, %368, %386, %352, %347, %345
  %398 = getelementptr inbounds i8, ptr %.0211326, i64 368
  %.0211 = load ptr, ptr %398, align 8, !tbaa !9
  %.not269 = icmp eq ptr %.0211, null
  br i1 %.not269, label %._crit_edge328.loopexit, label %.lr.ph327, !llvm.loop !49

._crit_edge328.loopexit:                          ; preds = %select.unfold
  %.pre = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !11
  br label %._crit_edge328

._crit_edge328:                                   ; preds = %._crit_edge328.loopexit, %.critedge295
  %399 = phi i8 [ %.pre, %._crit_edge328.loopexit ], [ %295, %.critedge295 ]
  %400 = and i8 %399, 2
  %.not284 = icmp eq i8 %400, 0
  br i1 %.not284, label %408, label %401, !prof !5

401:                                              ; preds = %._crit_edge328
  %402 = tail call i32 @cursor_validate(ptr noundef nonnull %0) #12
  br label %408

.thread:                                          ; preds = %343, %389, %394, %185, %190, %._crit_edge, %168
  %.7 = phi i32 [ %226, %._crit_edge ], [ %169, %168 ], [ %192, %190 ], [ %189, %185 ], [ %344, %343 ], [ %390, %389 ], [ %396, %394 ]
  %403 = getelementptr inbounds i8, ptr %0, i64 16
  %404 = load ptr, ptr %403, align 8, !tbaa !17
  %405 = getelementptr inbounds i8, ptr %404, i64 4
  %406 = load i32, ptr %405, align 4, !tbaa !50
  %407 = or i32 %406, 2
  store i32 %407, ptr %405, align 4, !tbaa !50
  br label %408

408:                                              ; preds = %4, %._crit_edge328, %401, %269, %283, %179, %.loopexit, %151, %72, %25, %27, %.thread, %2
  %.2 = phi i32 [ 61, %2 ], [ %5, %4 ], [ %.7, %.thread ], [ -30796, %27 ], [ -30796, %25 ], [ %75, %72 ], [ 0, %151 ], [ 0, %.loopexit ], [ -30784, %179 ], [ 0, %283 ], [ 0, %269 ], [ %402, %401 ], [ 0, %._crit_edge328 ]
  ret i32 %.2
}

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_dupfix_leaf(ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i32 @node_largedata_pgno(ptr noalias noundef) local_unnamed_addr #2

declare { ptr, i32 } @page_get_large(ptr noundef, i32 noundef, i64 noundef) local_unnamed_addr #6

; Function Attrs: inlinehint nounwind uwtable
declare hidden i32 @page_retire(ptr noundef, ptr noundef) local_unnamed_addr #7

declare void @node_del(ptr noundef, i64 noundef) local_unnamed_addr #6

; Function Attrs: inlinehint nounwind uwtable
declare hidden zeroext i1 @is_related(ptr noundef, ptr noundef) local_unnamed_addr #7

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @cursor_inner_refresh(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #7

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @check_leaf_type(ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_subpage(ptr noundef) local_unnamed_addr #2

declare ptr @node_shrink(ptr noundef, i64 noundef, ptr noundef) local_unnamed_addr #6

declare i32 @tree_drop(ptr noundef, i1 noundef zeroext) local_unnamed_addr #6

declare i32 @tree_rebalance(ptr noundef) local_unnamed_addr #6

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_inner(ptr noundef) local_unnamed_addr #2

attributes #0 = { cold nounwind optsize 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 #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 = { inlinehint mustprogress nofree nounwind willreturn memory(read) 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 = { 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 #4 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { 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 #6 = { "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 #7 = { inlinehint 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 #8 = { nounwind willreturn memory(read) }
attributes #9 = { hot }
attributes #10 = { noreturn nounwind }
attributes #11 = { nounwind }
attributes #12 = { cold }

!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 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!6 = !{!7, !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = !{!12, !7, i64 25}
!12 = !{!"libmdbx_globals", !7, i64 0, !13, i64 16, !13, i64 20, !7, i64 24, !7, i64 25, !7, i64 26, !14, i64 27, !13, i64 28, !7, i64 32, !7, i64 40, !15, i64 80, !10, i64 88}
!13 = !{!"int", !7, i64 0}
!14 = !{!"_Bool", !7, i64 0}
!15 = !{!"long", !7, i64 0}
!16 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!17 = !{!18, !10, i64 16}
!18 = !{!"MDBX_cursor", !13, i64 0, !7, i64 4, !7, i64 6, !7, i64 7, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !7, i64 48, !7, i64 304, !10, i64 368, !10, i64 376}
!19 = !{!20, !10, i64 80}
!20 = !{!"MDBX_txn", !13, i64 0, !13, i64 4, !15, i64 8, !15, i64 16, !10, i64 24, !10, i64 32, !21, i64 40, !15, i64 64, !15, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !10, i64 104, !10, i64 112, !10, i64 120, !23, i64 128, !10, i64 160, !7, i64 168}
!21 = !{!"geo", !22, i64 0, !22, i64 2, !13, i64 4, !13, i64 8, !7, i64 12, !7, i64 16}
!22 = !{!"short", !7, i64 0}
!23 = !{!"MDBX_canary", !15, i64 0, !15, i64 8, !15, i64 16, !15, i64 24}
!24 = !{!12, !7, i64 26}
!25 = !{!13, !13, i64 0}
!26 = !{!22, !22, i64 0}
!27 = !{!18, !10, i64 40}
!28 = !{!29, !15, i64 416}
!29 = !{!"inner_cursor", !18, i64 0, !30, i64 384}
!30 = !{!"tree", !22, i64 0, !22, i64 2, !13, i64 4, !13, i64 8, !13, i64 12, !13, i64 16, !13, i64 20, !15, i64 24, !15, i64 32, !15, i64 40}
!31 = !{!18, !10, i64 24}
!32 = !{!30, !15, i64 32}
!33 = !{!15, !15, i64 0}
!34 = !{!20, !15, i64 64}
!35 = !{!29, !15, i64 424}
!36 = !{!20, !10, i64 120}
!37 = !{!29, !13, i64 392}
!38 = distinct !{!38, !39}
!39 = !{!"llvm.loop.mustprogress"}
!40 = !{!30, !22, i64 2}
!41 = !{!30, !13, i64 8}
!42 = !{!29, !10, i64 24}
!43 = !{!30, !13, i64 4}
!44 = distinct !{!44, !39}
!45 = !{!"branch_weights", i32 4000000, i32 4001}
!46 = !{!"branch_weights", i32 2000, i32 2002}
!47 = !{!"branch_weights", i32 1, i32 2001, i32 2000}
!48 = !{!29, !22, i64 386}
!49 = distinct !{!49, !39}
!50 = !{!20, !13, i64 4}


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