; 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.cursor_set_result = type { i32, i8 }
%struct.iovec = type { ptr, i64 }
%struct.node_search_result = type { ptr, i8 }
%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.clc2 = type { %struct.clc, %struct.clc }
%struct.clc = type { ptr, i64, i64 }
%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.tree = type { i16, i16, i32, i32, i32, i32, i32, i64, i64, i64 }
%struct.anon = type { i8, i8 }
%struct.inner_cursor = type { %struct.MDBX_cursor, %struct.tree }
%struct.page = type <{ i64, i16, i16, %union.anon.18, i32, [0 x i16] }>
%union.anon.18 = type { i32 }

@globals = external global %struct.libmdbx_globals, align 8
@.str.54 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.91 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.92 = external hidden unnamed_addr constant [21 x i8], align 1
@.str.93 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.96 = external hidden unnamed_addr constant [51 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
@__func__.cursor_seek = external hidden unnamed_addr constant [12 x i8], align 1
@.str.105 = external hidden unnamed_addr constant [116 x i8], align 1
@.str.106 = external hidden unnamed_addr constant [27 x i8], align 1
@.str.107 = external hidden unnamed_addr constant [89 x i8], align 1
@.str.108 = external hidden unnamed_addr constant [21 x i8], align 1
@.str.109 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.110 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.111 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.112 = external hidden unnamed_addr constant [48 x i8], align 1
@.str.113 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.114 = external hidden unnamed_addr constant [44 x i8], align 1
@.str.115 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.116 = external hidden unnamed_addr constant [42 x i8], align 1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare ptr @mdbx_dump_val(ptr noundef, ptr noundef, i64 noundef) #6

; Function Attrs: hot nounwind uwtable
define dso_local i64 @cursor_seek(ptr noundef %0, ptr noundef %1, ptr noundef %2, i32 noundef %3) #7 {
  %5 = alloca %struct.cursor_set_result, align 4
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca i32, align 4
  %10 = alloca [510 x i8], align 16
  %11 = alloca i32, align 4
  %12 = alloca %struct.iovec, align 8
  %13 = alloca i64, align 8
  %14 = alloca ptr, align 8
  %15 = alloca ptr, align 8
  %16 = alloca i64, align 8
  %17 = alloca %struct.iovec, align 8
  %18 = alloca %struct.iovec, align 8
  %19 = alloca %struct.iovec, align 8
  %20 = alloca i32, align 4
  %21 = alloca %struct.iovec, align 8
  %22 = alloca %struct.iovec, align 8
  %23 = alloca i64, align 8
  %24 = alloca %struct.node_search_result, align 8
  %25 = alloca %struct.iovec, align 8
  %26 = alloca ptr, align 8
  %27 = alloca i64, align 8
  %28 = alloca %struct.iovec, align 8
  %29 = alloca %struct.iovec, align 8
  %30 = alloca %struct.cursor_set_result, align 4
  %31 = alloca %struct.iovec, align 8
  %32 = alloca i64, align 8
  %33 = alloca %struct.iovec, align 8
  %34 = alloca i32, align 4
  store ptr %0, ptr %6, align 8, !tbaa !5
  store ptr %1, ptr %7, align 8, !tbaa !5
  store ptr %2, ptr %8, align 8, !tbaa !5
  store i32 %3, ptr %9, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 510, ptr %10) #9
  %35 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 1
  store i8 0, ptr %35, align 4, !tbaa !11
  %36 = load ptr, ptr %7, align 8, !tbaa !5
  %37 = getelementptr inbounds %struct.iovec, ptr %36, i32 0, i32 1
  %38 = load i64, ptr %37, align 8, !tbaa !14
  %39 = load ptr, ptr %6, align 8, !tbaa !5
  %40 = getelementptr inbounds %struct.MDBX_cursor, ptr %39, i32 0, i32 7
  %41 = load ptr, ptr %40, align 8, !tbaa !17
  %42 = getelementptr inbounds %struct.clc2, ptr %41, i32 0, i32 0
  %43 = getelementptr inbounds %struct.clc, ptr %42, i32 0, i32 1
  %44 = load i64, ptr %43, align 8, !tbaa !19
  %45 = icmp ult i64 %38, %44
  br i1 %45, label %77, label %46

46:                                               ; preds = %4
  %47 = load ptr, ptr %7, align 8, !tbaa !5
  %48 = getelementptr inbounds %struct.iovec, ptr %47, i32 0, i32 1
  %49 = load i64, ptr %48, align 8, !tbaa !14
  %50 = load ptr, ptr %6, align 8, !tbaa !5
  %51 = getelementptr inbounds %struct.MDBX_cursor, ptr %50, i32 0, i32 7
  %52 = load ptr, ptr %51, align 8, !tbaa !17
  %53 = getelementptr inbounds %struct.clc2, ptr %52, i32 0, i32 0
  %54 = getelementptr inbounds %struct.clc, ptr %53, i32 0, i32 2
  %55 = load i64, ptr %54, align 8, !tbaa !22
  %56 = icmp ugt i64 %49, %55
  br i1 %56, label %57, label %75

57:                                               ; preds = %46
  %58 = load ptr, ptr %6, align 8, !tbaa !5
  %59 = getelementptr inbounds %struct.MDBX_cursor, ptr %58, i32 0, i32 7
  %60 = load ptr, ptr %59, align 8, !tbaa !17
  %61 = getelementptr inbounds %struct.clc2, ptr %60, i32 0, i32 0
  %62 = getelementptr inbounds %struct.clc, ptr %61, i32 0, i32 1
  %63 = load i64, ptr %62, align 8, !tbaa !19
  %64 = load ptr, ptr %6, align 8, !tbaa !5
  %65 = getelementptr inbounds %struct.MDBX_cursor, ptr %64, i32 0, i32 7
  %66 = load ptr, ptr %65, align 8, !tbaa !17
  %67 = getelementptr inbounds %struct.clc2, ptr %66, i32 0, i32 0
  %68 = getelementptr inbounds %struct.clc, ptr %67, i32 0, i32 2
  %69 = load i64, ptr %68, align 8, !tbaa !22
  %70 = icmp eq i64 %63, %69
  br i1 %70, label %73, label %71

71:                                               ; preds = %57
  br i1 true, label %73, label %72

72:                                               ; preds = %71
  br label %73

73:                                               ; preds = %72, %71, %57
  %74 = phi i1 [ true, %71 ], [ true, %57 ], [ false, %72 ]
  br label %75

75:                                               ; preds = %73, %46
  %76 = phi i1 [ false, %46 ], [ %74, %73 ]
  br label %77

77:                                               ; preds = %75, %4
  %78 = phi i1 [ true, %4 ], [ %76, %75 ]
  %79 = xor i1 %78, true
  %80 = xor i1 %79, true
  %81 = zext i1 %80 to i32
  %82 = sext i32 %81 to i64
  %83 = call i64 @llvm.expect.i64(i64 %82, i64 0)
  %84 = icmp ne i64 %83, 0
  br i1 %84, label %85, label %110

85:                                               ; preds = %77
  br label %86

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

97:                                               ; preds = %86
  br label %98

98:                                               ; preds = %97
  %99 = load ptr, ptr %6, align 8, !tbaa !5
  %100 = getelementptr inbounds %struct.MDBX_cursor, ptr %99, i32 0, i32 5
  %101 = load ptr, ptr %100, align 8, !tbaa !25
  %102 = getelementptr inbounds %struct.MDBX_txn, ptr %101, i32 0, i32 9
  %103 = load ptr, ptr %102, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %103, ptr noundef @.str.91, ptr noundef @__func__.cursor_seek, i32 noundef 1733) #10
  unreachable

104:                                              ; No predecessors!
  br label %105

105:                                              ; preds = %104
  br label %106

106:                                              ; preds = %105, %86
  br label %107

107:                                              ; preds = %106
  br label %108

108:                                              ; preds = %107
  %109 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30781, ptr %109, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1732

110:                                              ; preds = %77
  call void @llvm.lifetime.start.p0(i64 16, ptr %12) #9
  %111 = load ptr, ptr %7, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %12, ptr align 8 %111, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #9
  %112 = load ptr, ptr %6, align 8, !tbaa !5
  %113 = getelementptr inbounds %struct.MDBX_cursor, ptr %112, i32 0, i32 6
  %114 = load ptr, ptr %113, align 8, !tbaa !34
  %115 = getelementptr inbounds %struct.tree, ptr %114, i32 0, i32 0
  %116 = load i16, ptr %115, align 4, !tbaa !35
  %117 = zext i16 %116 to i32
  %118 = and i32 %117, 8
  %119 = icmp ne i32 %118, 0
  br i1 %119, label %120, label %191

120:                                              ; preds = %110
  %121 = getelementptr inbounds %struct.iovec, ptr %12, i32 0, i32 1
  %122 = load i64, ptr %121, align 8, !tbaa !14
  %123 = icmp eq i64 %122, 8
  br i1 %123, label %124, label %142

124:                                              ; preds = %120
  %125 = getelementptr inbounds %struct.iovec, ptr %12, i32 0, i32 0
  %126 = load ptr, ptr %125, align 8, !tbaa !37
  %127 = ptrtoint ptr %126 to i64
  %128 = and i64 7, %127
  %129 = icmp ne i64 %128, 0
  %130 = xor i1 %129, true
  %131 = xor i1 %130, true
  %132 = zext i1 %131 to i32
  %133 = sext i32 %132 to i64
  %134 = call i64 @llvm.expect.i64(i64 %133, i64 0)
  %135 = icmp ne i64 %134, 0
  br i1 %135, label %136, label %141

136:                                              ; preds = %124
  %137 = getelementptr inbounds %struct.iovec, ptr %12, i32 0, i32 0
  %138 = load ptr, ptr %137, align 8, !tbaa !37
  %139 = call ptr @bcopy_8(ptr noundef %13, ptr noundef %138)
  %140 = getelementptr inbounds %struct.iovec, ptr %12, i32 0, i32 0
  store ptr %139, ptr %140, align 8, !tbaa !37
  br label %141

141:                                              ; preds = %136, %124
  br label %190

142:                                              ; preds = %120
  %143 = getelementptr inbounds %struct.iovec, ptr %12, i32 0, i32 1
  %144 = load i64, ptr %143, align 8, !tbaa !14
  %145 = icmp eq i64 %144, 4
  br i1 %145, label %146, label %164

146:                                              ; preds = %142
  %147 = getelementptr inbounds %struct.iovec, ptr %12, i32 0, i32 0
  %148 = load ptr, ptr %147, align 8, !tbaa !37
  %149 = ptrtoint ptr %148 to i64
  %150 = and i64 3, %149
  %151 = icmp ne i64 %150, 0
  %152 = xor i1 %151, true
  %153 = xor i1 %152, true
  %154 = zext i1 %153 to i32
  %155 = sext i32 %154 to i64
  %156 = call i64 @llvm.expect.i64(i64 %155, i64 0)
  %157 = icmp ne i64 %156, 0
  br i1 %157, label %158, label %163

158:                                              ; preds = %146
  %159 = getelementptr inbounds %struct.iovec, ptr %12, i32 0, i32 0
  %160 = load ptr, ptr %159, align 8, !tbaa !37
  %161 = call ptr @bcopy_4(ptr noundef %13, ptr noundef %160)
  %162 = getelementptr inbounds %struct.iovec, ptr %12, i32 0, i32 0
  store ptr %161, ptr %162, align 8, !tbaa !37
  br label %163

163:                                              ; preds = %158, %146
  br label %189

164:                                              ; preds = %142
  br label %165

165:                                              ; preds = %164
  %166 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %167 = zext i8 %166 to i32
  %168 = and i32 %167, 1
  %169 = icmp ne i32 %168, 0
  %170 = xor i1 %169, true
  %171 = xor i1 %170, true
  %172 = zext i1 %171 to i32
  %173 = sext i32 %172 to i64
  %174 = call i64 @llvm.expect.i64(i64 %173, i64 1)
  %175 = icmp ne i64 %174, 0
  br i1 %175, label %176, label %185

176:                                              ; preds = %165
  br label %177

177:                                              ; preds = %176
  %178 = load ptr, ptr %6, align 8, !tbaa !5
  %179 = getelementptr inbounds %struct.MDBX_cursor, ptr %178, i32 0, i32 5
  %180 = load ptr, ptr %179, align 8, !tbaa !25
  %181 = getelementptr inbounds %struct.MDBX_txn, ptr %180, i32 0, i32 9
  %182 = load ptr, ptr %181, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %182, ptr noundef @.str.93, ptr noundef @__func__.cursor_seek, i32 noundef 1750) #10
  unreachable

183:                                              ; No predecessors!
  br label %184

184:                                              ; preds = %183
  br label %185

185:                                              ; preds = %184, %165
  br label %186

186:                                              ; preds = %185
  br label %187

187:                                              ; preds = %186
  %188 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30781, ptr %188, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1731

189:                                              ; preds = %163
  br label %190

190:                                              ; preds = %189, %141
  br label %191

191:                                              ; preds = %190, %110
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #9
  store ptr null, ptr %15, align 8, !tbaa !5
  %192 = load ptr, ptr %6, align 8, !tbaa !5
  %193 = call zeroext i1 @is_pointed(ptr noundef %192) #11
  br i1 %193, label %194, label %736

194:                                              ; preds = %191
  %195 = load ptr, ptr %6, align 8, !tbaa !5
  %196 = getelementptr inbounds %struct.MDBX_cursor, ptr %195, i32 0, i32 9
  %197 = load ptr, ptr %6, align 8, !tbaa !5
  %198 = getelementptr inbounds %struct.MDBX_cursor, ptr %197, i32 0, i32 1
  %199 = getelementptr inbounds %struct.anon, ptr %198, i32 0, i32 1
  %200 = load i8, ptr %199, align 1, !tbaa !38
  %201 = sext i8 %200 to i64
  %202 = getelementptr inbounds [32 x ptr], ptr %196, i64 0, i64 %201
  %203 = load ptr, ptr %202, align 8, !tbaa !5
  store ptr %203, ptr %14, align 8, !tbaa !5
  br label %204

204:                                              ; preds = %194
  %205 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %206 = zext i8 %205 to i32
  %207 = and i32 %206, 1
  %208 = icmp ne i32 %207, 0
  %209 = xor i1 %208, true
  %210 = xor i1 %209, true
  %211 = zext i1 %210 to i32
  %212 = sext i32 %211 to i64
  %213 = call i64 @llvm.expect.i64(i64 %212, i64 1)
  %214 = icmp ne i64 %213, 0
  br i1 %214, label %215, label %235

215:                                              ; preds = %204
  br label %216

216:                                              ; preds = %215
  %217 = load ptr, ptr %14, align 8, !tbaa !5
  %218 = call zeroext i1 @is_leaf(ptr noundef %217) #11
  %219 = xor i1 %218, true
  %220 = xor i1 %219, true
  %221 = xor i1 %220, true
  %222 = zext i1 %221 to i32
  %223 = sext i32 %222 to i64
  %224 = call i64 @llvm.expect.i64(i64 %223, i64 0)
  %225 = icmp ne i64 %224, 0
  br i1 %225, label %226, label %232

226:                                              ; preds = %216
  %227 = load ptr, ptr %6, align 8, !tbaa !5
  %228 = getelementptr inbounds %struct.MDBX_cursor, ptr %227, i32 0, i32 5
  %229 = load ptr, ptr %228, align 8, !tbaa !25
  %230 = getelementptr inbounds %struct.MDBX_txn, ptr %229, i32 0, i32 9
  %231 = load ptr, ptr %230, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %231, ptr noundef @.str.100, ptr noundef @__func__.cursor_seek, i32 noundef 1761) #10
  unreachable

232:                                              ; preds = %216
  br label %233

233:                                              ; preds = %232
  br label %234

234:                                              ; preds = %233
  br label %235

235:                                              ; preds = %234, %204
  br label %236

236:                                              ; preds = %235
  br label %237

237:                                              ; preds = %236
  %238 = load ptr, ptr %14, align 8, !tbaa !5
  %239 = call i64 @page_numkeys(ptr noundef %238) #11
  store i64 %239, ptr %16, align 8, !tbaa !33
  %240 = load i64, ptr %16, align 8, !tbaa !33
  %241 = icmp eq i64 %240, 0
  %242 = xor i1 %241, true
  %243 = xor i1 %242, true
  %244 = zext i1 %243 to i32
  %245 = sext i32 %244 to i64
  %246 = call i64 @llvm.expect.i64(i64 %245, i64 0)
  %247 = icmp ne i64 %246, 0
  br i1 %247, label %248, label %319

248:                                              ; preds = %237
  br label %249

249:                                              ; preds = %248
  %250 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %251 = zext i8 %250 to i32
  %252 = and i32 %251, 1
  %253 = icmp ne i32 %252, 0
  %254 = xor i1 %253, true
  %255 = xor i1 %254, true
  %256 = zext i1 %255 to i32
  %257 = sext i32 %256 to i64
  %258 = call i64 @llvm.expect.i64(i64 %257, i64 1)
  %259 = icmp ne i64 %258, 0
  br i1 %259, label %260, label %315

260:                                              ; preds = %249
  br label %261

261:                                              ; preds = %260
  %262 = load ptr, ptr %6, align 8, !tbaa !5
  %263 = getelementptr inbounds %struct.MDBX_cursor, ptr %262, i32 0, i32 1
  %264 = getelementptr inbounds %struct.anon, ptr %263, i32 0, i32 1
  %265 = load i8, ptr %264, align 1, !tbaa !38
  %266 = sext i8 %265 to i32
  %267 = icmp eq i32 %266, 0
  br i1 %267, label %268, label %297

268:                                              ; preds = %261
  %269 = load ptr, ptr %6, align 8, !tbaa !5
  %270 = getelementptr inbounds %struct.MDBX_cursor, ptr %269, i32 0, i32 6
  %271 = load ptr, ptr %270, align 8, !tbaa !34
  %272 = getelementptr inbounds %struct.tree, ptr %271, i32 0, i32 1
  %273 = load i16, ptr %272, align 2, !tbaa !39
  %274 = zext i16 %273 to i32
  %275 = icmp eq i32 %274, 1
  br i1 %275, label %276, label %297

276:                                              ; preds = %268
  %277 = load ptr, ptr %6, align 8, !tbaa !5
  %278 = getelementptr inbounds %struct.MDBX_cursor, ptr %277, i32 0, i32 6
  %279 = load ptr, ptr %278, align 8, !tbaa !34
  %280 = getelementptr inbounds %struct.tree, ptr %279, i32 0, i32 4
  %281 = load i32, ptr %280, align 4, !tbaa !40
  %282 = icmp eq i32 %281, 0
  br i1 %282, label %283, label %297

283:                                              ; preds = %276
  %284 = load ptr, ptr %6, align 8, !tbaa !5
  %285 = getelementptr inbounds %struct.MDBX_cursor, ptr %284, i32 0, i32 6
  %286 = load ptr, ptr %285, align 8, !tbaa !34
  %287 = getelementptr inbounds %struct.tree, ptr %286, i32 0, i32 5
  %288 = load i32, ptr %287, align 4, !tbaa !41
  %289 = icmp eq i32 %288, 1
  br i1 %289, label %290, label %297

290:                                              ; preds = %283
  %291 = load ptr, ptr %6, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.MDBX_cursor, ptr %291, i32 0, i32 10
  %293 = getelementptr inbounds [32 x i16], ptr %292, i64 0, i64 0
  %294 = load i16, ptr %293, align 8, !tbaa !42
  %295 = zext i16 %294 to i32
  %296 = icmp eq i32 %295, 0
  br label %297

297:                                              ; preds = %290, %283, %276, %268, %261
  %298 = phi i1 [ false, %283 ], [ false, %276 ], [ false, %268 ], [ false, %261 ], [ %296, %290 ]
  %299 = xor i1 %298, true
  %300 = xor i1 %299, true
  %301 = xor i1 %300, true
  %302 = zext i1 %301 to i32
  %303 = sext i32 %302 to i64
  %304 = call i64 @llvm.expect.i64(i64 %303, i64 0)
  %305 = icmp ne i64 %304, 0
  br i1 %305, label %306, label %312

306:                                              ; preds = %297
  %307 = load ptr, ptr %6, align 8, !tbaa !5
  %308 = getelementptr inbounds %struct.MDBX_cursor, ptr %307, i32 0, i32 5
  %309 = load ptr, ptr %308, align 8, !tbaa !25
  %310 = getelementptr inbounds %struct.MDBX_txn, ptr %309, i32 0, i32 9
  %311 = load ptr, ptr %310, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %311, ptr noundef @.str.105, ptr noundef @__func__.cursor_seek, i32 noundef 1766) #10
  unreachable

312:                                              ; preds = %297
  br label %313

313:                                              ; preds = %312
  br label %314

314:                                              ; preds = %313
  br label %315

315:                                              ; preds = %314, %249
  br label %316

316:                                              ; preds = %315
  br label %317

317:                                              ; preds = %316
  %318 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30798, ptr %318, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1730

319:                                              ; preds = %237
  %320 = load ptr, ptr %14, align 8, !tbaa !5
  %321 = call zeroext i1 @is_dupfix_leaf(ptr noundef %320) #11
  br i1 %321, label %322, label %335

322:                                              ; preds = %319
  call void @llvm.lifetime.start.p0(i64 16, ptr %18) #9
  %323 = load ptr, ptr %14, align 8, !tbaa !5
  %324 = load ptr, ptr %6, align 8, !tbaa !5
  %325 = getelementptr inbounds %struct.MDBX_cursor, ptr %324, i32 0, i32 6
  %326 = load ptr, ptr %325, align 8, !tbaa !34
  %327 = getelementptr inbounds %struct.tree, ptr %326, i32 0, i32 2
  %328 = load i32, ptr %327, align 4, !tbaa !43
  %329 = zext i32 %328 to i64
  %330 = call { ptr, i64 } @page_dupfix_key(ptr noundef %323, i64 noundef 0, i64 noundef %329) #11
  %331 = getelementptr inbounds { ptr, i64 }, ptr %18, i32 0, i32 0
  %332 = extractvalue { ptr, i64 } %330, 0
  store ptr %332, ptr %331, align 8
  %333 = getelementptr inbounds { ptr, i64 }, ptr %18, i32 0, i32 1
  %334 = extractvalue { ptr, i64 } %330, 1
  store i64 %334, ptr %333, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %17, ptr align 8 %18, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.end.p0(i64 16, ptr %18) #9
  br label %345

335:                                              ; preds = %319
  %336 = load ptr, ptr %14, align 8, !tbaa !5
  %337 = call ptr @page_node(ptr noundef %336, i64 noundef 0) #11
  store ptr %337, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %19) #9
  %338 = load ptr, ptr %15, align 8, !tbaa !5
  %339 = call { ptr, i64 } @get_key(ptr noundef %338) #11
  %340 = getelementptr inbounds { ptr, i64 }, ptr %19, i32 0, i32 0
  %341 = extractvalue { ptr, i64 } %339, 0
  store ptr %341, ptr %340, align 8
  %342 = getelementptr inbounds { ptr, i64 }, ptr %19, i32 0, i32 1
  %343 = extractvalue { ptr, i64 } %339, 1
  store i64 %343, ptr %342, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %17, ptr align 8 %19, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.end.p0(i64 16, ptr %19) #9
  %344 = load ptr, ptr %6, align 8, !tbaa !5
  call void @inner_gone(ptr noundef %344)
  br label %345

345:                                              ; preds = %335, %322
  %346 = load ptr, ptr %6, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.MDBX_cursor, ptr %346, i32 0, i32 7
  %348 = load ptr, ptr %347, align 8, !tbaa !17
  %349 = getelementptr inbounds %struct.clc2, ptr %348, i32 0, i32 0
  %350 = getelementptr inbounds %struct.clc, ptr %349, i32 0, i32 0
  %351 = load ptr, ptr %350, align 8, !tbaa !44
  %352 = call i32 %351(ptr noundef %12, ptr noundef %17)
  store i32 %352, ptr %20, align 4, !tbaa !9
  %353 = load i32, ptr %20, align 4, !tbaa !9
  %354 = icmp eq i32 %353, 0
  %355 = xor i1 %354, true
  %356 = xor i1 %355, true
  %357 = zext i1 %356 to i32
  %358 = sext i32 %357 to i64
  %359 = call i64 @llvm.expect.i64(i64 %358, i64 0)
  %360 = icmp ne i64 %359, 0
  br i1 %360, label %361, label %371

361:                                              ; preds = %345
  %362 = load ptr, ptr %6, align 8, !tbaa !5
  %363 = getelementptr inbounds %struct.MDBX_cursor, ptr %362, i32 0, i32 10
  %364 = load ptr, ptr %6, align 8, !tbaa !5
  %365 = getelementptr inbounds %struct.MDBX_cursor, ptr %364, i32 0, i32 1
  %366 = getelementptr inbounds %struct.anon, ptr %365, i32 0, i32 1
  %367 = load i8, ptr %366, align 1, !tbaa !38
  %368 = sext i8 %367 to i64
  %369 = getelementptr inbounds [32 x i16], ptr %363, i64 0, i64 %368
  store i16 0, ptr %369, align 2, !tbaa !42
  %370 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 1
  store i8 1, ptr %370, align 4, !tbaa !11
  br label %1043

371:                                              ; preds = %345
  %372 = load i32, ptr %20, align 4, !tbaa !9
  %373 = icmp sgt i32 %372, 0
  br i1 %373, label %374, label %715

374:                                              ; preds = %371
  %375 = load i64, ptr %16, align 8, !tbaa !33
  %376 = icmp ugt i64 %375, 1
  %377 = xor i1 %376, true
  %378 = xor i1 %377, true
  %379 = zext i1 %378 to i32
  %380 = sext i32 %379 to i64
  %381 = call i64 @llvm.expect.i64(i64 %380, i64 1)
  %382 = icmp ne i64 %381, 0
  br i1 %382, label %383, label %510

383:                                              ; preds = %374
  %384 = load ptr, ptr %14, align 8, !tbaa !5
  %385 = call zeroext i1 @is_dupfix_leaf(ptr noundef %384) #11
  br i1 %385, label %386, label %394

386:                                              ; preds = %383
  %387 = load ptr, ptr %14, align 8, !tbaa !5
  %388 = load i64, ptr %16, align 8, !tbaa !33
  %389 = sub i64 %388, 1
  %390 = getelementptr inbounds %struct.iovec, ptr %17, i32 0, i32 1
  %391 = load i64, ptr %390, align 8, !tbaa !14
  %392 = call ptr @page_dupfix_ptr(ptr noundef %387, i64 noundef %389, i64 noundef %391) #11
  %393 = getelementptr inbounds %struct.iovec, ptr %17, i32 0, i32 0
  store ptr %392, ptr %393, align 8, !tbaa !37
  br label %405

394:                                              ; preds = %383
  %395 = load ptr, ptr %14, align 8, !tbaa !5
  %396 = load i64, ptr %16, align 8, !tbaa !33
  %397 = sub i64 %396, 1
  %398 = call ptr @page_node(ptr noundef %395, i64 noundef %397) #11
  store ptr %398, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %21) #9
  %399 = load ptr, ptr %15, align 8, !tbaa !5
  %400 = call { ptr, i64 } @get_key(ptr noundef %399) #11
  %401 = getelementptr inbounds { ptr, i64 }, ptr %21, i32 0, i32 0
  %402 = extractvalue { ptr, i64 } %400, 0
  store ptr %402, ptr %401, align 8
  %403 = getelementptr inbounds { ptr, i64 }, ptr %21, i32 0, i32 1
  %404 = extractvalue { ptr, i64 } %400, 1
  store i64 %404, ptr %403, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %17, ptr align 8 %21, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.end.p0(i64 16, ptr %21) #9
  br label %405

405:                                              ; preds = %394, %386
  %406 = load ptr, ptr %6, align 8, !tbaa !5
  %407 = getelementptr inbounds %struct.MDBX_cursor, ptr %406, i32 0, i32 7
  %408 = load ptr, ptr %407, align 8, !tbaa !17
  %409 = getelementptr inbounds %struct.clc2, ptr %408, i32 0, i32 0
  %410 = getelementptr inbounds %struct.clc, ptr %409, i32 0, i32 0
  %411 = load ptr, ptr %410, align 8, !tbaa !44
  %412 = call i32 %411(ptr noundef %12, ptr noundef %17)
  store i32 %412, ptr %20, align 4, !tbaa !9
  %413 = load i32, ptr %20, align 4, !tbaa !9
  %414 = icmp eq i32 %413, 0
  br i1 %414, label %415, label %428

415:                                              ; preds = %405
  %416 = load i64, ptr %16, align 8, !tbaa !33
  %417 = sub i64 %416, 1
  %418 = trunc i64 %417 to i16
  %419 = load ptr, ptr %6, align 8, !tbaa !5
  %420 = getelementptr inbounds %struct.MDBX_cursor, ptr %419, i32 0, i32 10
  %421 = load ptr, ptr %6, align 8, !tbaa !5
  %422 = getelementptr inbounds %struct.MDBX_cursor, ptr %421, i32 0, i32 1
  %423 = getelementptr inbounds %struct.anon, ptr %422, i32 0, i32 1
  %424 = load i8, ptr %423, align 1, !tbaa !38
  %425 = sext i8 %424 to i64
  %426 = getelementptr inbounds [32 x i16], ptr %420, i64 0, i64 %425
  store i16 %418, ptr %426, align 2, !tbaa !42
  %427 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 1
  store i8 1, ptr %427, align 4, !tbaa !11
  br label %1043

428:                                              ; preds = %405
  %429 = load i32, ptr %20, align 4, !tbaa !9
  %430 = icmp slt i32 %429, 0
  br i1 %430, label %431, label %509

431:                                              ; preds = %428
  %432 = load ptr, ptr %6, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct.MDBX_cursor, ptr %432, i32 0, i32 10
  %434 = load ptr, ptr %6, align 8, !tbaa !5
  %435 = getelementptr inbounds %struct.MDBX_cursor, ptr %434, i32 0, i32 1
  %436 = getelementptr inbounds %struct.anon, ptr %435, i32 0, i32 1
  %437 = load i8, ptr %436, align 1, !tbaa !38
  %438 = sext i8 %437 to i64
  %439 = getelementptr inbounds [32 x i16], ptr %433, i64 0, i64 %438
  %440 = load i16, ptr %439, align 2, !tbaa !42
  %441 = zext i16 %440 to i32
  %442 = icmp sgt i32 %441, 0
  br i1 %442, label %443, label %508

443:                                              ; preds = %431
  %444 = load ptr, ptr %6, align 8, !tbaa !5
  %445 = getelementptr inbounds %struct.MDBX_cursor, ptr %444, i32 0, i32 10
  %446 = load ptr, ptr %6, align 8, !tbaa !5
  %447 = getelementptr inbounds %struct.MDBX_cursor, ptr %446, i32 0, i32 1
  %448 = getelementptr inbounds %struct.anon, ptr %447, i32 0, i32 1
  %449 = load i8, ptr %448, align 1, !tbaa !38
  %450 = sext i8 %449 to i64
  %451 = getelementptr inbounds [32 x i16], ptr %445, i64 0, i64 %450
  %452 = load i16, ptr %451, align 2, !tbaa !42
  %453 = zext i16 %452 to i64
  %454 = load i64, ptr %16, align 8, !tbaa !33
  %455 = sub i64 %454, 1
  %456 = icmp ult i64 %453, %455
  br i1 %456, label %457, label %508

457:                                              ; preds = %443
  %458 = load ptr, ptr %14, align 8, !tbaa !5
  %459 = call zeroext i1 @is_dupfix_leaf(ptr noundef %458) #11
  br i1 %459, label %460, label %476

460:                                              ; preds = %457
  %461 = load ptr, ptr %14, align 8, !tbaa !5
  %462 = load ptr, ptr %6, align 8, !tbaa !5
  %463 = getelementptr inbounds %struct.MDBX_cursor, ptr %462, i32 0, i32 10
  %464 = load ptr, ptr %6, align 8, !tbaa !5
  %465 = getelementptr inbounds %struct.MDBX_cursor, ptr %464, i32 0, i32 1
  %466 = getelementptr inbounds %struct.anon, ptr %465, i32 0, i32 1
  %467 = load i8, ptr %466, align 1, !tbaa !38
  %468 = sext i8 %467 to i64
  %469 = getelementptr inbounds [32 x i16], ptr %463, i64 0, i64 %468
  %470 = load i16, ptr %469, align 2, !tbaa !42
  %471 = zext i16 %470 to i64
  %472 = getelementptr inbounds %struct.iovec, ptr %17, i32 0, i32 1
  %473 = load i64, ptr %472, align 8, !tbaa !14
  %474 = call ptr @page_dupfix_ptr(ptr noundef %461, i64 noundef %471, i64 noundef %473) #11
  %475 = getelementptr inbounds %struct.iovec, ptr %17, i32 0, i32 0
  store ptr %474, ptr %475, align 8, !tbaa !37
  br label %495

476:                                              ; preds = %457
  %477 = load ptr, ptr %14, align 8, !tbaa !5
  %478 = load ptr, ptr %6, align 8, !tbaa !5
  %479 = getelementptr inbounds %struct.MDBX_cursor, ptr %478, i32 0, i32 10
  %480 = load ptr, ptr %6, align 8, !tbaa !5
  %481 = getelementptr inbounds %struct.MDBX_cursor, ptr %480, i32 0, i32 1
  %482 = getelementptr inbounds %struct.anon, ptr %481, i32 0, i32 1
  %483 = load i8, ptr %482, align 1, !tbaa !38
  %484 = sext i8 %483 to i64
  %485 = getelementptr inbounds [32 x i16], ptr %479, i64 0, i64 %484
  %486 = load i16, ptr %485, align 2, !tbaa !42
  %487 = zext i16 %486 to i64
  %488 = call ptr @page_node(ptr noundef %477, i64 noundef %487) #11
  store ptr %488, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %22) #9
  %489 = load ptr, ptr %15, align 8, !tbaa !5
  %490 = call { ptr, i64 } @get_key(ptr noundef %489) #11
  %491 = getelementptr inbounds { ptr, i64 }, ptr %22, i32 0, i32 0
  %492 = extractvalue { ptr, i64 } %490, 0
  store ptr %492, ptr %491, align 8
  %493 = getelementptr inbounds { ptr, i64 }, ptr %22, i32 0, i32 1
  %494 = extractvalue { ptr, i64 } %490, 1
  store i64 %494, ptr %493, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %17, ptr align 8 %22, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.end.p0(i64 16, ptr %22) #9
  br label %495

495:                                              ; preds = %476, %460
  %496 = load ptr, ptr %6, align 8, !tbaa !5
  %497 = getelementptr inbounds %struct.MDBX_cursor, ptr %496, i32 0, i32 7
  %498 = load ptr, ptr %497, align 8, !tbaa !17
  %499 = getelementptr inbounds %struct.clc2, ptr %498, i32 0, i32 0
  %500 = getelementptr inbounds %struct.clc, ptr %499, i32 0, i32 0
  %501 = load ptr, ptr %500, align 8, !tbaa !44
  %502 = call i32 %501(ptr noundef %12, ptr noundef %17)
  store i32 %502, ptr %20, align 4, !tbaa !9
  %503 = load i32, ptr %20, align 4, !tbaa !9
  %504 = icmp eq i32 %503, 0
  br i1 %504, label %505, label %507

505:                                              ; preds = %495
  %506 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 1
  store i8 1, ptr %506, align 4, !tbaa !11
  br label %1043

507:                                              ; preds = %495
  br label %508

508:                                              ; preds = %507, %443, %431
  br label %899

509:                                              ; preds = %428
  br label %510

510:                                              ; preds = %509, %374
  br label %511

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

522:                                              ; preds = %511
  br label %523

523:                                              ; preds = %522
  %524 = load ptr, ptr %6, align 8, !tbaa !5
  %525 = getelementptr inbounds %struct.MDBX_cursor, ptr %524, i32 0, i32 6
  %526 = load ptr, ptr %525, align 8, !tbaa !34
  %527 = getelementptr inbounds %struct.tree, ptr %526, i32 0, i32 1
  %528 = load i16, ptr %527, align 2, !tbaa !39
  %529 = zext i16 %528 to i32
  %530 = load ptr, ptr %6, align 8, !tbaa !5
  %531 = getelementptr inbounds %struct.MDBX_cursor, ptr %530, i32 0, i32 1
  %532 = getelementptr inbounds %struct.anon, ptr %531, i32 0, i32 1
  %533 = load i8, ptr %532, align 1, !tbaa !38
  %534 = sext i8 %533 to i32
  %535 = icmp sgt i32 %529, %534
  %536 = xor i1 %535, true
  %537 = xor i1 %536, true
  %538 = xor i1 %537, true
  %539 = zext i1 %538 to i32
  %540 = sext i32 %539 to i64
  %541 = call i64 @llvm.expect.i64(i64 %540, i64 0)
  %542 = icmp ne i64 %541, 0
  br i1 %542, label %543, label %549

543:                                              ; preds = %523
  %544 = load ptr, ptr %6, align 8, !tbaa !5
  %545 = getelementptr inbounds %struct.MDBX_cursor, ptr %544, i32 0, i32 5
  %546 = load ptr, ptr %545, align 8, !tbaa !25
  %547 = getelementptr inbounds %struct.MDBX_txn, ptr %546, i32 0, i32 9
  %548 = load ptr, ptr %547, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %548, ptr noundef @.str.106, ptr noundef @__func__.cursor_seek, i32 noundef 1833) #10
  unreachable

549:                                              ; preds = %523
  br label %550

550:                                              ; preds = %549
  br label %551

551:                                              ; preds = %550
  br label %552

552:                                              ; preds = %551, %511
  br label %553

553:                                              ; preds = %552
  br label %554

554:                                              ; preds = %553
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #9
  store i64 0, ptr %23, align 8, !tbaa !33
  br label %555

555:                                              ; preds = %581, %554
  %556 = load i64, ptr %23, align 8, !tbaa !33
  %557 = load ptr, ptr %6, align 8, !tbaa !5
  %558 = getelementptr inbounds %struct.MDBX_cursor, ptr %557, i32 0, i32 1
  %559 = getelementptr inbounds %struct.anon, ptr %558, i32 0, i32 1
  %560 = load i8, ptr %559, align 1, !tbaa !38
  %561 = sext i8 %560 to i64
  %562 = icmp slt i64 %556, %561
  br i1 %562, label %564, label %563

563:                                              ; preds = %555
  store i32 24, ptr %11, align 4
  br label %584

564:                                              ; preds = %555
  %565 = load ptr, ptr %6, align 8, !tbaa !5
  %566 = getelementptr inbounds %struct.MDBX_cursor, ptr %565, i32 0, i32 10
  %567 = load i64, ptr %23, align 8, !tbaa !33
  %568 = getelementptr inbounds [32 x i16], ptr %566, i64 0, i64 %567
  %569 = load i16, ptr %568, align 2, !tbaa !42
  %570 = zext i16 %569 to i64
  %571 = add i64 %570, 1
  %572 = load ptr, ptr %6, align 8, !tbaa !5
  %573 = getelementptr inbounds %struct.MDBX_cursor, ptr %572, i32 0, i32 9
  %574 = load i64, ptr %23, align 8, !tbaa !33
  %575 = getelementptr inbounds [32 x ptr], ptr %573, i64 0, i64 %574
  %576 = load ptr, ptr %575, align 8, !tbaa !5
  %577 = call i64 @page_numkeys(ptr noundef %576) #11
  %578 = icmp ult i64 %571, %577
  br i1 %578, label %579, label %580

579:                                              ; preds = %564
  store i32 27, ptr %11, align 4
  br label %584

580:                                              ; preds = %564
  br label %581

581:                                              ; preds = %580
  %582 = load i64, ptr %23, align 8, !tbaa !33
  %583 = add nsw i64 %582, 1
  store i64 %583, ptr %23, align 8, !tbaa !33
  br label %555, !llvm.loop !45

584:                                              ; preds = %579, %563
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #9
  %585 = load i32, ptr %11, align 4
  switch i32 %585, label %1730 [
    i32 24, label %586
    i32 27, label %772
  ]

586:                                              ; preds = %584
  %587 = load i64, ptr %16, align 8, !tbaa !33
  %588 = trunc i64 %587 to i16
  %589 = load ptr, ptr %6, align 8, !tbaa !5
  %590 = getelementptr inbounds %struct.MDBX_cursor, ptr %589, i32 0, i32 10
  %591 = load ptr, ptr %6, align 8, !tbaa !5
  %592 = getelementptr inbounds %struct.MDBX_cursor, ptr %591, i32 0, i32 1
  %593 = getelementptr inbounds %struct.anon, ptr %592, i32 0, i32 1
  %594 = load i8, ptr %593, align 1, !tbaa !38
  %595 = sext i8 %594 to i64
  %596 = getelementptr inbounds [32 x i16], ptr %590, i64 0, i64 %595
  store i16 %588, ptr %596, align 2, !tbaa !42
  %597 = load i32, ptr %9, align 4, !tbaa !9
  %598 = icmp ult i32 %597, 17
  br i1 %598, label %599, label %668

599:                                              ; preds = %586
  br label %600

600:                                              ; preds = %1668, %1435, %1426, %959, %734, %599
  br label %601

601:                                              ; preds = %600
  %602 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %603 = zext i8 %602 to i32
  %604 = and i32 %603, 1
  %605 = icmp ne i32 %604, 0
  %606 = xor i1 %605, true
  %607 = xor i1 %606, true
  %608 = zext i1 %607 to i32
  %609 = sext i32 %608 to i64
  %610 = call i64 @llvm.expect.i64(i64 %609, i64 1)
  %611 = icmp ne i64 %610, 0
  br i1 %611, label %612, label %643

612:                                              ; preds = %601
  br label %613

613:                                              ; preds = %612
  %614 = load i32, ptr %9, align 4, !tbaa !9
  %615 = icmp eq i32 %614, 15
  br i1 %615, label %625, label %616

616:                                              ; preds = %613
  %617 = load i32, ptr %9, align 4, !tbaa !9
  %618 = icmp eq i32 %617, 16
  br i1 %618, label %625, label %619

619:                                              ; preds = %616
  %620 = load i32, ptr %9, align 4, !tbaa !9
  %621 = icmp eq i32 %620, 2
  br i1 %621, label %625, label %622

622:                                              ; preds = %619
  %623 = load i32, ptr %9, align 4, !tbaa !9
  %624 = icmp eq i32 %623, 3
  br label %625

625:                                              ; preds = %622, %619, %616, %613
  %626 = phi i1 [ true, %619 ], [ true, %616 ], [ true, %613 ], [ %624, %622 ]
  %627 = xor i1 %626, true
  %628 = xor i1 %627, true
  %629 = xor i1 %628, true
  %630 = zext i1 %629 to i32
  %631 = sext i32 %630 to i64
  %632 = call i64 @llvm.expect.i64(i64 %631, i64 0)
  %633 = icmp ne i64 %632, 0
  br i1 %633, label %634, label %640

634:                                              ; preds = %625
  %635 = load ptr, ptr %6, align 8, !tbaa !5
  %636 = getelementptr inbounds %struct.MDBX_cursor, ptr %635, i32 0, i32 5
  %637 = load ptr, ptr %636, align 8, !tbaa !25
  %638 = getelementptr inbounds %struct.MDBX_txn, ptr %637, i32 0, i32 9
  %639 = load ptr, ptr %638, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %639, ptr noundef @.str.107, ptr noundef @__func__.cursor_seek, i32 noundef 1842) #10
  unreachable

640:                                              ; preds = %625
  br label %641

641:                                              ; preds = %640
  br label %642

642:                                              ; preds = %641
  br label %643

643:                                              ; preds = %642, %601
  br label %644

644:                                              ; preds = %643
  br label %645

645:                                              ; preds = %644
  %646 = load ptr, ptr %6, align 8, !tbaa !5
  %647 = getelementptr inbounds %struct.MDBX_cursor, ptr %646, i32 0, i32 1
  %648 = getelementptr inbounds %struct.anon, ptr %647, i32 0, i32 0
  %649 = load i8, ptr %648, align 4, !tbaa !38
  %650 = sext i8 %649 to i32
  %651 = or i32 %650, -128
  %652 = trunc i32 %651 to i8
  store i8 %652, ptr %648, align 4, !tbaa !38
  %653 = load ptr, ptr %6, align 8, !tbaa !5
  %654 = call zeroext i1 @inner_pointed(ptr noundef %653) #11
  br i1 %654, label %655, label %666

655:                                              ; preds = %645
  %656 = load ptr, ptr %6, align 8, !tbaa !5
  %657 = getelementptr inbounds %struct.MDBX_cursor, ptr %656, i32 0, i32 8
  %658 = load ptr, ptr %657, align 8, !tbaa !47
  %659 = getelementptr inbounds %struct.inner_cursor, ptr %658, i32 0, i32 0
  %660 = getelementptr inbounds %struct.MDBX_cursor, ptr %659, i32 0, i32 1
  %661 = getelementptr inbounds %struct.anon, ptr %660, i32 0, i32 0
  %662 = load i8, ptr %661, align 4, !tbaa !38
  %663 = sext i8 %662 to i32
  %664 = or i32 %663, -128
  %665 = trunc i32 %664 to i8
  store i8 %665, ptr %661, align 4, !tbaa !38
  br label %666

666:                                              ; preds = %655, %645
  %667 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30798, ptr %667, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1730

668:                                              ; preds = %586
  br label %669

669:                                              ; preds = %668
  %670 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %671 = zext i8 %670 to i32
  %672 = and i32 %671, 1
  %673 = icmp ne i32 %672, 0
  %674 = xor i1 %673, true
  %675 = xor i1 %674, true
  %676 = zext i1 %675 to i32
  %677 = sext i32 %676 to i64
  %678 = call i64 @llvm.expect.i64(i64 %677, i64 1)
  %679 = icmp ne i64 %678, 0
  br i1 %679, label %680, label %700

680:                                              ; preds = %669
  br label %681

681:                                              ; preds = %680
  %682 = load i32, ptr %9, align 4, !tbaa !9
  %683 = icmp eq i32 %682, 17
  %684 = xor i1 %683, true
  %685 = xor i1 %684, true
  %686 = xor i1 %685, true
  %687 = zext i1 %686 to i32
  %688 = sext i32 %687 to i64
  %689 = call i64 @llvm.expect.i64(i64 %688, i64 0)
  %690 = icmp ne i64 %689, 0
  br i1 %690, label %691, label %697

691:                                              ; preds = %681
  %692 = load ptr, ptr %6, align 8, !tbaa !5
  %693 = getelementptr inbounds %struct.MDBX_cursor, ptr %692, i32 0, i32 5
  %694 = load ptr, ptr %693, align 8, !tbaa !25
  %695 = getelementptr inbounds %struct.MDBX_txn, ptr %694, i32 0, i32 9
  %696 = load ptr, ptr %695, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %696, ptr noundef @.str.108, ptr noundef @__func__.cursor_seek, i32 noundef 1853) #10
  unreachable

697:                                              ; preds = %681
  br label %698

698:                                              ; preds = %697
  br label %699

699:                                              ; preds = %698
  br label %700

700:                                              ; preds = %699, %669
  br label %701

701:                                              ; preds = %700
  br label %702

702:                                              ; preds = %701
  %703 = load ptr, ptr %6, align 8, !tbaa !5
  %704 = getelementptr inbounds %struct.MDBX_cursor, ptr %703, i32 0, i32 1
  %705 = getelementptr inbounds %struct.anon, ptr %704, i32 0, i32 0
  %706 = load i8, ptr %705, align 4, !tbaa !38
  %707 = sext i8 %706 to i32
  %708 = and i32 %707, 3
  %709 = or i32 96, %708
  %710 = trunc i32 %709 to i8
  %711 = load ptr, ptr %6, align 8, !tbaa !5
  %712 = getelementptr inbounds %struct.MDBX_cursor, ptr %711, i32 0, i32 1
  %713 = getelementptr inbounds %struct.anon, ptr %712, i32 0, i32 0
  store i8 %710, ptr %713, align 4, !tbaa !38
  %714 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30798, ptr %714, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1730

715:                                              ; preds = %371
  %716 = load ptr, ptr %6, align 8, !tbaa !5
  %717 = getelementptr inbounds %struct.MDBX_cursor, ptr %716, i32 0, i32 1
  %718 = getelementptr inbounds %struct.anon, ptr %717, i32 0, i32 1
  %719 = load i8, ptr %718, align 1, !tbaa !38
  %720 = sext i8 %719 to i32
  %721 = icmp eq i32 %720, 0
  br i1 %721, label %722, label %735

722:                                              ; preds = %715
  %723 = load ptr, ptr %6, align 8, !tbaa !5
  %724 = getelementptr inbounds %struct.MDBX_cursor, ptr %723, i32 0, i32 10
  %725 = load ptr, ptr %6, align 8, !tbaa !5
  %726 = getelementptr inbounds %struct.MDBX_cursor, ptr %725, i32 0, i32 1
  %727 = getelementptr inbounds %struct.anon, ptr %726, i32 0, i32 1
  %728 = load i8, ptr %727, align 1, !tbaa !38
  %729 = sext i8 %728 to i64
  %730 = getelementptr inbounds [32 x i16], ptr %724, i64 0, i64 %729
  store i16 0, ptr %730, align 2, !tbaa !42
  %731 = load i32, ptr %9, align 4, !tbaa !9
  %732 = icmp uge i32 %731, 17
  br i1 %732, label %733, label %734

733:                                              ; preds = %722
  br label %1043

734:                                              ; preds = %722
  br label %600

735:                                              ; preds = %715
  br label %736

736:                                              ; preds = %735, %191
  br label %737

737:                                              ; preds = %736
  %738 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %739 = zext i8 %738 to i32
  %740 = and i32 %739, 1
  %741 = icmp ne i32 %740, 0
  %742 = xor i1 %741, true
  %743 = xor i1 %742, true
  %744 = zext i1 %743 to i32
  %745 = sext i32 %744 to i64
  %746 = call i64 @llvm.expect.i64(i64 %745, i64 1)
  %747 = icmp ne i64 %746, 0
  br i1 %747, label %748, label %769

748:                                              ; preds = %737
  br label %749

749:                                              ; preds = %748
  %750 = load ptr, ptr %6, align 8, !tbaa !5
  %751 = call zeroext i1 @inner_pointed(ptr noundef %750) #11
  %752 = xor i1 %751, true
  %753 = xor i1 %752, true
  %754 = xor i1 %753, true
  %755 = xor i1 %754, true
  %756 = zext i1 %755 to i32
  %757 = sext i32 %756 to i64
  %758 = call i64 @llvm.expect.i64(i64 %757, i64 0)
  %759 = icmp ne i64 %758, 0
  br i1 %759, label %760, label %766

760:                                              ; preds = %749
  %761 = load ptr, ptr %6, align 8, !tbaa !5
  %762 = getelementptr inbounds %struct.MDBX_cursor, ptr %761, i32 0, i32 5
  %763 = load ptr, ptr %762, align 8, !tbaa !25
  %764 = getelementptr inbounds %struct.MDBX_txn, ptr %763, i32 0, i32 9
  %765 = load ptr, ptr %764, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %765, ptr noundef @.str.99, ptr noundef @__func__.cursor_seek, i32 noundef 1868) #10
  unreachable

766:                                              ; preds = %749
  br label %767

767:                                              ; preds = %766
  br label %768

768:                                              ; preds = %767
  br label %769

769:                                              ; preds = %768, %737
  br label %770

770:                                              ; preds = %769
  br label %771

771:                                              ; preds = %770
  br label %772

772:                                              ; preds = %771, %584
  %773 = load ptr, ptr %6, align 8, !tbaa !5
  %774 = call i32 @tree_search(ptr noundef %773, ptr noundef %12, i32 noundef 0)
  %775 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 %774, ptr %775, align 4, !tbaa !31
  %776 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  %777 = load i32, ptr %776, align 4, !tbaa !31
  %778 = icmp ne i32 %777, 0
  %779 = xor i1 %778, true
  %780 = xor i1 %779, true
  %781 = zext i1 %780 to i32
  %782 = sext i32 %781 to i64
  %783 = call i64 @llvm.expect.i64(i64 %782, i64 0)
  %784 = icmp ne i64 %783, 0
  br i1 %784, label %785, label %786

785:                                              ; preds = %772
  store i32 1, ptr %11, align 4
  br label %1730

786:                                              ; preds = %772
  br label %787

787:                                              ; preds = %786
  %788 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %789 = zext i8 %788 to i32
  %790 = and i32 %789, 1
  %791 = icmp ne i32 %790, 0
  %792 = xor i1 %791, true
  %793 = xor i1 %792, true
  %794 = zext i1 %793 to i32
  %795 = sext i32 %794 to i64
  %796 = call i64 @llvm.expect.i64(i64 %795, i64 1)
  %797 = icmp ne i64 %796, 0
  br i1 %797, label %798, label %824

798:                                              ; preds = %787
  br label %799

799:                                              ; preds = %798
  %800 = load ptr, ptr %6, align 8, !tbaa !5
  %801 = call zeroext i1 @is_pointed(ptr noundef %800) #11
  br i1 %801, label %802, label %806

802:                                              ; preds = %799
  %803 = load ptr, ptr %6, align 8, !tbaa !5
  %804 = call zeroext i1 @inner_pointed(ptr noundef %803) #11
  %805 = xor i1 %804, true
  br label %806

806:                                              ; preds = %802, %799
  %807 = phi i1 [ false, %799 ], [ %805, %802 ]
  %808 = xor i1 %807, true
  %809 = xor i1 %808, true
  %810 = xor i1 %809, true
  %811 = zext i1 %810 to i32
  %812 = sext i32 %811 to i64
  %813 = call i64 @llvm.expect.i64(i64 %812, i64 0)
  %814 = icmp ne i64 %813, 0
  br i1 %814, label %815, label %821

815:                                              ; preds = %806
  %816 = load ptr, ptr %6, align 8, !tbaa !5
  %817 = getelementptr inbounds %struct.MDBX_cursor, ptr %816, i32 0, i32 5
  %818 = load ptr, ptr %817, align 8, !tbaa !25
  %819 = getelementptr inbounds %struct.MDBX_txn, ptr %818, i32 0, i32 9
  %820 = load ptr, ptr %819, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %820, ptr noundef @.str.109, ptr noundef @__func__.cursor_seek, i32 noundef 1875) #10
  unreachable

821:                                              ; preds = %806
  br label %822

822:                                              ; preds = %821
  br label %823

823:                                              ; preds = %822
  br label %824

824:                                              ; preds = %823, %787
  br label %825

825:                                              ; preds = %824
  br label %826

826:                                              ; preds = %825
  %827 = load ptr, ptr %6, align 8, !tbaa !5
  %828 = getelementptr inbounds %struct.MDBX_cursor, ptr %827, i32 0, i32 9
  %829 = load ptr, ptr %6, align 8, !tbaa !5
  %830 = getelementptr inbounds %struct.MDBX_cursor, ptr %829, i32 0, i32 1
  %831 = getelementptr inbounds %struct.anon, ptr %830, i32 0, i32 1
  %832 = load i8, ptr %831, align 1, !tbaa !38
  %833 = sext i8 %832 to i64
  %834 = getelementptr inbounds [32 x ptr], ptr %828, i64 0, i64 %833
  %835 = load ptr, ptr %834, align 8, !tbaa !5
  store ptr %835, ptr %14, align 8, !tbaa !5
  br label %836

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

847:                                              ; preds = %836
  br label %848

848:                                              ; preds = %847
  %849 = load ptr, ptr %14, align 8, !tbaa !5
  %850 = icmp ne ptr %849, null
  %851 = xor i1 %850, true
  %852 = xor i1 %851, true
  %853 = xor i1 %852, true
  %854 = zext i1 %853 to i32
  %855 = sext i32 %854 to i64
  %856 = call i64 @llvm.expect.i64(i64 %855, i64 0)
  %857 = icmp ne i64 %856, 0
  br i1 %857, label %858, label %859

858:                                              ; preds = %848
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.110, ptr noundef @__func__.cursor_seek, i32 noundef 1877) #10
  unreachable

859:                                              ; preds = %848
  br label %860

860:                                              ; preds = %859
  br label %861

861:                                              ; preds = %860
  br label %862

862:                                              ; preds = %861, %836
  br label %863

863:                                              ; preds = %862
  br label %864

864:                                              ; preds = %863
  br label %865

865:                                              ; preds = %864
  %866 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %867 = zext i8 %866 to i32
  %868 = and i32 %867, 1
  %869 = icmp ne i32 %868, 0
  %870 = xor i1 %869, true
  %871 = xor i1 %870, true
  %872 = zext i1 %871 to i32
  %873 = sext i32 %872 to i64
  %874 = call i64 @llvm.expect.i64(i64 %873, i64 1)
  %875 = icmp ne i64 %874, 0
  br i1 %875, label %876, label %896

876:                                              ; preds = %865
  br label %877

877:                                              ; preds = %876
  %878 = load ptr, ptr %14, align 8, !tbaa !5
  %879 = call zeroext i1 @is_leaf(ptr noundef %878) #11
  %880 = xor i1 %879, true
  %881 = xor i1 %880, true
  %882 = xor i1 %881, true
  %883 = zext i1 %882 to i32
  %884 = sext i32 %883 to i64
  %885 = call i64 @llvm.expect.i64(i64 %884, i64 0)
  %886 = icmp ne i64 %885, 0
  br i1 %886, label %887, label %893

887:                                              ; preds = %877
  %888 = load ptr, ptr %6, align 8, !tbaa !5
  %889 = getelementptr inbounds %struct.MDBX_cursor, ptr %888, i32 0, i32 5
  %890 = load ptr, ptr %889, align 8, !tbaa !25
  %891 = getelementptr inbounds %struct.MDBX_txn, ptr %890, i32 0, i32 9
  %892 = load ptr, ptr %891, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %892, ptr noundef @.str.100, ptr noundef @__func__.cursor_seek, i32 noundef 1878) #10
  unreachable

893:                                              ; preds = %877
  br label %894

894:                                              ; preds = %893
  br label %895

895:                                              ; preds = %894
  br label %896

896:                                              ; preds = %895, %865
  br label %897

897:                                              ; preds = %896
  br label %898

898:                                              ; preds = %897
  br label %899

899:                                              ; preds = %898, %508
  br label %900

900:                                              ; preds = %899
  %901 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %902 = zext i8 %901 to i32
  %903 = and i32 %902, 1
  %904 = icmp ne i32 %903, 0
  %905 = xor i1 %904, true
  %906 = xor i1 %905, true
  %907 = zext i1 %906 to i32
  %908 = sext i32 %907 to i64
  %909 = call i64 @llvm.expect.i64(i64 %908, i64 1)
  %910 = icmp ne i64 %909, 0
  br i1 %910, label %911, label %937

911:                                              ; preds = %900
  br label %912

912:                                              ; preds = %911
  %913 = load ptr, ptr %6, align 8, !tbaa !5
  %914 = call zeroext i1 @is_pointed(ptr noundef %913) #11
  br i1 %914, label %915, label %919

915:                                              ; preds = %912
  %916 = load ptr, ptr %6, align 8, !tbaa !5
  %917 = call zeroext i1 @inner_pointed(ptr noundef %916) #11
  %918 = xor i1 %917, true
  br label %919

919:                                              ; preds = %915, %912
  %920 = phi i1 [ false, %912 ], [ %918, %915 ]
  %921 = xor i1 %920, true
  %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 0)
  %927 = icmp ne i64 %926, 0
  br i1 %927, label %928, label %934

928:                                              ; preds = %919
  %929 = load ptr, ptr %6, align 8, !tbaa !5
  %930 = getelementptr inbounds %struct.MDBX_cursor, ptr %929, i32 0, i32 5
  %931 = load ptr, ptr %930, align 8, !tbaa !25
  %932 = getelementptr inbounds %struct.MDBX_txn, ptr %931, i32 0, i32 9
  %933 = load ptr, ptr %932, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %933, ptr noundef @.str.109, ptr noundef @__func__.cursor_seek, i32 noundef 1881) #10
  unreachable

934:                                              ; preds = %919
  br label %935

935:                                              ; preds = %934
  br label %936

936:                                              ; preds = %935
  br label %937

937:                                              ; preds = %936, %900
  br label %938

938:                                              ; preds = %937
  br label %939

939:                                              ; preds = %938
  %940 = load ptr, ptr %6, align 8, !tbaa !5
  %941 = call { ptr, i8 } @node_search(ptr noundef %940, ptr noundef %12)
  %942 = getelementptr inbounds { ptr, i8 }, ptr %24, i32 0, i32 0
  %943 = extractvalue { ptr, i8 } %941, 0
  store ptr %943, ptr %942, align 8
  %944 = getelementptr inbounds { ptr, i8 }, ptr %24, i32 0, i32 1
  %945 = extractvalue { ptr, i8 } %941, 1
  store i8 %945, ptr %944, align 8
  %946 = getelementptr inbounds %struct.node_search_result, ptr %24, i32 0, i32 0
  %947 = load ptr, ptr %946, align 8, !tbaa !48
  store ptr %947, ptr %15, align 8, !tbaa !5
  %948 = getelementptr inbounds %struct.node_search_result, ptr %24, i32 0, i32 1
  %949 = load i8, ptr %948, align 8, !tbaa !50, !range !51, !noundef !52
  %950 = trunc i8 %949 to i1
  %951 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 1
  %952 = zext i1 %950 to i8
  store i8 %952, ptr %951, align 4, !tbaa !11
  %953 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 1
  %954 = load i8, ptr %953, align 4, !tbaa !11, !range !51, !noundef !52
  %955 = trunc i8 %954 to i1
  br i1 %955, label %1042, label %956

956:                                              ; preds = %939
  %957 = load i32, ptr %9, align 4, !tbaa !9
  %958 = icmp ult i32 %957, 17
  br i1 %958, label %959, label %960

959:                                              ; preds = %956
  br label %600

960:                                              ; preds = %956
  %961 = load ptr, ptr %15, align 8, !tbaa !5
  %962 = icmp eq ptr %961, null
  br i1 %962, label %963, label %1041

963:                                              ; preds = %960
  br label %964

964:                                              ; preds = %963
  %965 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !53
  %966 = zext i8 %965 to i32
  %967 = icmp sle i32 5, %966
  %968 = xor i1 %967, true
  %969 = xor i1 %968, true
  %970 = zext i1 %969 to i32
  %971 = sext i32 %970 to i64
  %972 = call i64 @llvm.expect.i64(i64 %971, i64 0)
  %973 = icmp ne i64 %972, 0
  br i1 %973, label %974, label %975

974:                                              ; preds = %964
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.cursor_seek, i32 noundef 1890, ptr noundef @.str.54, ptr noundef @.str.111)
  br label %975

975:                                              ; preds = %974, %964
  br label %976

976:                                              ; preds = %975
  br label %977

977:                                              ; preds = %976
  %978 = load ptr, ptr %6, align 8, !tbaa !5
  %979 = call i32 @cursor_sibling_right(ptr noundef %978) #12
  %980 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 %979, ptr %980, align 4, !tbaa !31
  %981 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  %982 = load i32, ptr %981, align 4, !tbaa !31
  %983 = icmp ne i32 %982, 0
  %984 = xor i1 %983, true
  %985 = xor i1 %984, true
  %986 = zext i1 %985 to i32
  %987 = sext i32 %986 to i64
  %988 = call i64 @llvm.expect.i64(i64 %987, i64 0)
  %989 = icmp ne i64 %988, 0
  br i1 %989, label %990, label %991

990:                                              ; preds = %977
  store i32 1, ptr %11, align 4
  br label %1730

991:                                              ; preds = %977
  %992 = load ptr, ptr %6, align 8, !tbaa !5
  %993 = getelementptr inbounds %struct.MDBX_cursor, ptr %992, i32 0, i32 9
  %994 = load ptr, ptr %6, align 8, !tbaa !5
  %995 = getelementptr inbounds %struct.MDBX_cursor, ptr %994, i32 0, i32 1
  %996 = getelementptr inbounds %struct.anon, ptr %995, i32 0, i32 1
  %997 = load i8, ptr %996, align 1, !tbaa !38
  %998 = sext i8 %997 to i64
  %999 = getelementptr inbounds [32 x ptr], ptr %993, i64 0, i64 %998
  %1000 = load ptr, ptr %999, align 8, !tbaa !5
  store ptr %1000, ptr %14, align 8, !tbaa !5
  br label %1001

1001:                                             ; preds = %991
  %1002 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1003 = zext i8 %1002 to i32
  %1004 = and i32 %1003, 1
  %1005 = icmp ne i32 %1004, 0
  %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 1)
  %1011 = icmp ne i64 %1010, 0
  br i1 %1011, label %1012, label %1032

1012:                                             ; preds = %1001
  br label %1013

1013:                                             ; preds = %1012
  %1014 = load ptr, ptr %14, align 8, !tbaa !5
  %1015 = call zeroext i1 @is_leaf(ptr noundef %1014) #11
  %1016 = xor i1 %1015, true
  %1017 = xor i1 %1016, true
  %1018 = xor i1 %1017, true
  %1019 = zext i1 %1018 to i32
  %1020 = sext i32 %1019 to i64
  %1021 = call i64 @llvm.expect.i64(i64 %1020, i64 0)
  %1022 = icmp ne i64 %1021, 0
  br i1 %1022, label %1023, label %1029

1023:                                             ; preds = %1013
  %1024 = load ptr, ptr %6, align 8, !tbaa !5
  %1025 = getelementptr inbounds %struct.MDBX_cursor, ptr %1024, i32 0, i32 5
  %1026 = load ptr, ptr %1025, align 8, !tbaa !25
  %1027 = getelementptr inbounds %struct.MDBX_txn, ptr %1026, i32 0, i32 9
  %1028 = load ptr, ptr %1027, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %1028, ptr noundef @.str.100, ptr noundef @__func__.cursor_seek, i32 noundef 1895) #10
  unreachable

1029:                                             ; preds = %1013
  br label %1030

1030:                                             ; preds = %1029
  br label %1031

1031:                                             ; preds = %1030
  br label %1032

1032:                                             ; preds = %1031, %1001
  br label %1033

1033:                                             ; preds = %1032
  br label %1034

1034:                                             ; preds = %1033
  %1035 = load ptr, ptr %14, align 8, !tbaa !5
  %1036 = call zeroext i1 @is_dupfix_leaf(ptr noundef %1035) #11
  br i1 %1036, label %1040, label %1037

1037:                                             ; preds = %1034
  %1038 = load ptr, ptr %14, align 8, !tbaa !5
  %1039 = call ptr @page_node(ptr noundef %1038, i64 noundef 0) #11
  store ptr %1039, ptr %15, align 8, !tbaa !5
  br label %1040

1040:                                             ; preds = %1037, %1034
  br label %1041

1041:                                             ; preds = %1040, %960
  br label %1042

1042:                                             ; preds = %1041, %939
  br label %1043

1043:                                             ; preds = %1042, %733, %505, %415, %361
  br label %1044

1044:                                             ; preds = %1043
  %1045 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1046 = zext i8 %1045 to i32
  %1047 = and i32 %1046, 1
  %1048 = icmp ne i32 %1047, 0
  %1049 = xor i1 %1048, true
  %1050 = xor i1 %1049, true
  %1051 = zext i1 %1050 to i32
  %1052 = sext i32 %1051 to i64
  %1053 = call i64 @llvm.expect.i64(i64 %1052, i64 1)
  %1054 = icmp ne i64 %1053, 0
  br i1 %1054, label %1055, label %1081

1055:                                             ; preds = %1044
  br label %1056

1056:                                             ; preds = %1055
  %1057 = load ptr, ptr %6, align 8, !tbaa !5
  %1058 = call zeroext i1 @is_pointed(ptr noundef %1057) #11
  br i1 %1058, label %1059, label %1063

1059:                                             ; preds = %1056
  %1060 = load ptr, ptr %6, align 8, !tbaa !5
  %1061 = call zeroext i1 @inner_pointed(ptr noundef %1060) #11
  %1062 = xor i1 %1061, true
  br label %1063

1063:                                             ; preds = %1059, %1056
  %1064 = phi i1 [ false, %1056 ], [ %1062, %1059 ]
  %1065 = xor i1 %1064, true
  %1066 = xor i1 %1065, true
  %1067 = xor i1 %1066, true
  %1068 = zext i1 %1067 to i32
  %1069 = sext i32 %1068 to i64
  %1070 = call i64 @llvm.expect.i64(i64 %1069, i64 0)
  %1071 = icmp ne i64 %1070, 0
  br i1 %1071, label %1072, label %1078

1072:                                             ; preds = %1063
  %1073 = load ptr, ptr %6, align 8, !tbaa !5
  %1074 = getelementptr inbounds %struct.MDBX_cursor, ptr %1073, i32 0, i32 5
  %1075 = load ptr, ptr %1074, align 8, !tbaa !25
  %1076 = getelementptr inbounds %struct.MDBX_txn, ptr %1075, i32 0, i32 9
  %1077 = load ptr, ptr %1076, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %1077, ptr noundef @.str.109, ptr noundef @__func__.cursor_seek, i32 noundef 1902) #10
  unreachable

1078:                                             ; preds = %1063
  br label %1079

1079:                                             ; preds = %1078
  br label %1080

1080:                                             ; preds = %1079
  br label %1081

1081:                                             ; preds = %1080, %1044
  br label %1082

1082:                                             ; preds = %1081
  br label %1083

1083:                                             ; preds = %1082
  br label %1084

1084:                                             ; preds = %1083
  %1085 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1086 = zext i8 %1085 to i32
  %1087 = and i32 %1086, 1
  %1088 = icmp ne i32 %1087, 0
  %1089 = xor i1 %1088, true
  %1090 = xor i1 %1089, true
  %1091 = zext i1 %1090 to i32
  %1092 = sext i32 %1091 to i64
  %1093 = call i64 @llvm.expect.i64(i64 %1092, i64 1)
  %1094 = icmp ne i64 %1093, 0
  br i1 %1094, label %1095, label %1134

1095:                                             ; preds = %1084
  br label %1096

1096:                                             ; preds = %1095
  %1097 = load ptr, ptr %6, align 8, !tbaa !5
  %1098 = getelementptr inbounds %struct.MDBX_cursor, ptr %1097, i32 0, i32 10
  %1099 = load ptr, ptr %6, align 8, !tbaa !5
  %1100 = getelementptr inbounds %struct.MDBX_cursor, ptr %1099, i32 0, i32 1
  %1101 = getelementptr inbounds %struct.anon, ptr %1100, i32 0, i32 1
  %1102 = load i8, ptr %1101, align 1, !tbaa !38
  %1103 = sext i8 %1102 to i64
  %1104 = getelementptr inbounds [32 x i16], ptr %1098, i64 0, i64 %1103
  %1105 = load i16, ptr %1104, align 2, !tbaa !42
  %1106 = zext i16 %1105 to i64
  %1107 = load ptr, ptr %6, align 8, !tbaa !5
  %1108 = getelementptr inbounds %struct.MDBX_cursor, ptr %1107, i32 0, i32 9
  %1109 = load ptr, ptr %6, align 8, !tbaa !5
  %1110 = getelementptr inbounds %struct.MDBX_cursor, ptr %1109, i32 0, i32 1
  %1111 = getelementptr inbounds %struct.anon, ptr %1110, i32 0, i32 1
  %1112 = load i8, ptr %1111, align 1, !tbaa !38
  %1113 = sext i8 %1112 to i64
  %1114 = getelementptr inbounds [32 x ptr], ptr %1108, i64 0, i64 %1113
  %1115 = load ptr, ptr %1114, align 8, !tbaa !5
  %1116 = call i64 @page_numkeys(ptr noundef %1115) #11
  %1117 = icmp ult i64 %1106, %1116
  %1118 = xor i1 %1117, true
  %1119 = xor i1 %1118, true
  %1120 = xor i1 %1119, true
  %1121 = zext i1 %1120 to i32
  %1122 = sext i32 %1121 to i64
  %1123 = call i64 @llvm.expect.i64(i64 %1122, i64 0)
  %1124 = icmp ne i64 %1123, 0
  br i1 %1124, label %1125, label %1131

1125:                                             ; preds = %1096
  %1126 = load ptr, ptr %6, align 8, !tbaa !5
  %1127 = getelementptr inbounds %struct.MDBX_cursor, ptr %1126, i32 0, i32 5
  %1128 = load ptr, ptr %1127, align 8, !tbaa !25
  %1129 = getelementptr inbounds %struct.MDBX_txn, ptr %1128, i32 0, i32 9
  %1130 = load ptr, ptr %1129, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %1130, ptr noundef @.str.112, ptr noundef @__func__.cursor_seek, i32 noundef 1903) #10
  unreachable

1131:                                             ; preds = %1096
  br label %1132

1132:                                             ; preds = %1131
  br label %1133

1133:                                             ; preds = %1132
  br label %1134

1134:                                             ; preds = %1133, %1084
  br label %1135

1135:                                             ; preds = %1134
  br label %1136

1136:                                             ; preds = %1135
  %1137 = load ptr, ptr %6, align 8, !tbaa !5
  %1138 = load ptr, ptr %14, align 8, !tbaa !5
  %1139 = call zeroext i1 @check_leaf_type(ptr noundef %1137, ptr noundef %1138) #11
  %1140 = xor i1 %1139, true
  %1141 = xor i1 %1140, true
  %1142 = xor i1 %1141, true
  %1143 = zext i1 %1142 to i32
  %1144 = sext i32 %1143 to i64
  %1145 = call i64 @llvm.expect.i64(i64 %1144, i64 0)
  %1146 = icmp ne i64 %1145, 0
  br i1 %1146, label %1147, label %1170

1147:                                             ; preds = %1136
  br label %1148

1148:                                             ; preds = %1147
  %1149 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !53
  %1150 = zext i8 %1149 to i32
  %1151 = icmp sle i32 1, %1150
  %1152 = xor i1 %1151, true
  %1153 = xor i1 %1152, true
  %1154 = zext i1 %1153 to i32
  %1155 = sext i32 %1154 to i64
  %1156 = call i64 @llvm.expect.i64(i64 %1155, i64 0)
  %1157 = icmp ne i64 %1156, 0
  br i1 %1157, label %1158, label %1166

1158:                                             ; preds = %1148
  %1159 = load ptr, ptr %14, align 8, !tbaa !5
  %1160 = getelementptr inbounds %struct.page, ptr %1159, i32 0, i32 4
  %1161 = load i32, ptr %1160, align 1, !tbaa !9
  %1162 = load ptr, ptr %14, align 8, !tbaa !5
  %1163 = getelementptr inbounds %struct.page, ptr %1162, i32 0, i32 2
  %1164 = load i16, ptr %1163, align 1, !tbaa !42
  %1165 = zext i16 %1164 to i32
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 1, ptr noundef @__func__.cursor_seek, i32 noundef 1905, ptr noundef @.str.96, i32 noundef %1161, i32 noundef %1165)
  br label %1166

1166:                                             ; preds = %1158, %1148
  br label %1167

1167:                                             ; preds = %1166
  br label %1168

1168:                                             ; preds = %1167
  %1169 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30796, ptr %1169, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1730

1170:                                             ; preds = %1136
  %1171 = load ptr, ptr %14, align 8, !tbaa !5
  %1172 = call zeroext i1 @is_dupfix_leaf(ptr noundef %1171) #11
  br i1 %1172, label %1173, label %1203

1173:                                             ; preds = %1170
  %1174 = load i32, ptr %9, align 4, !tbaa !9
  %1175 = icmp uge i32 %1174, 16
  br i1 %1175, label %1176, label %1200

1176:                                             ; preds = %1173
  %1177 = load ptr, ptr %7, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %25) #9
  %1178 = load ptr, ptr %14, align 8, !tbaa !5
  %1179 = load ptr, ptr %6, align 8, !tbaa !5
  %1180 = getelementptr inbounds %struct.MDBX_cursor, ptr %1179, i32 0, i32 10
  %1181 = load ptr, ptr %6, align 8, !tbaa !5
  %1182 = getelementptr inbounds %struct.MDBX_cursor, ptr %1181, i32 0, i32 1
  %1183 = getelementptr inbounds %struct.anon, ptr %1182, i32 0, i32 1
  %1184 = load i8, ptr %1183, align 1, !tbaa !38
  %1185 = sext i8 %1184 to i64
  %1186 = getelementptr inbounds [32 x i16], ptr %1180, i64 0, i64 %1185
  %1187 = load i16, ptr %1186, align 2, !tbaa !42
  %1188 = zext i16 %1187 to i64
  %1189 = load ptr, ptr %6, align 8, !tbaa !5
  %1190 = getelementptr inbounds %struct.MDBX_cursor, ptr %1189, i32 0, i32 6
  %1191 = load ptr, ptr %1190, align 8, !tbaa !34
  %1192 = getelementptr inbounds %struct.tree, ptr %1191, i32 0, i32 2
  %1193 = load i32, ptr %1192, align 4, !tbaa !43
  %1194 = zext i32 %1193 to i64
  %1195 = call { ptr, i64 } @page_dupfix_key(ptr noundef %1178, i64 noundef %1188, i64 noundef %1194) #11
  %1196 = getelementptr inbounds { ptr, i64 }, ptr %25, i32 0, i32 0
  %1197 = extractvalue { ptr, i64 } %1195, 0
  store ptr %1197, ptr %1196, align 8
  %1198 = getelementptr inbounds { ptr, i64 }, ptr %25, i32 0, i32 1
  %1199 = extractvalue { ptr, i64 } %1195, 1
  store i64 %1199, ptr %1198, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1177, ptr align 8 %25, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.end.p0(i64 16, ptr %25) #9
  br label %1200

1200:                                             ; preds = %1176, %1173
  %1201 = load ptr, ptr %6, align 8, !tbaa !5
  call void @be_filled(ptr noundef %1201)
  %1202 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 0, ptr %1202, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1730

1203:                                             ; preds = %1170
  %1204 = load ptr, ptr %15, align 8, !tbaa !5
  %1205 = call zeroext i8 @node_flags(ptr noundef %1204) #11
  %1206 = zext i8 %1205 to i32
  %1207 = and i32 %1206, 4
  %1208 = icmp ne i32 %1207, 0
  br i1 %1208, label %1209, label %1438

1209:                                             ; preds = %1203
  %1210 = load ptr, ptr %6, align 8, !tbaa !5
  %1211 = load ptr, ptr %15, align 8, !tbaa !5
  %1212 = load ptr, ptr %14, align 8, !tbaa !5
  %1213 = call i32 @cursor_dupsort_setup(ptr noundef %1210, ptr noundef %1211, ptr noundef %1212)
  %1214 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 %1213, ptr %1214, align 4, !tbaa !31
  %1215 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  %1216 = load i32, ptr %1215, align 4, !tbaa !31
  %1217 = icmp ne i32 %1216, 0
  %1218 = xor i1 %1217, true
  %1219 = xor i1 %1218, true
  %1220 = zext i1 %1219 to i32
  %1221 = sext i32 %1220 to i64
  %1222 = call i64 @llvm.expect.i64(i64 %1221, i64 0)
  %1223 = icmp ne i64 %1222, 0
  br i1 %1223, label %1224, label %1225

1224:                                             ; preds = %1209
  store i32 1, ptr %11, align 4
  br label %1730

1225:                                             ; preds = %1209
  %1226 = load i32, ptr %9, align 4, !tbaa !9
  %1227 = icmp uge i32 %1226, 15
  br i1 %1227, label %1228, label %1372

1228:                                             ; preds = %1225
  br label %1229

1229:                                             ; preds = %1228
  %1230 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1231 = zext i8 %1230 to i32
  %1232 = and i32 %1231, 1
  %1233 = icmp ne i32 %1232, 0
  %1234 = xor i1 %1233, true
  %1235 = xor i1 %1234, true
  %1236 = zext i1 %1235 to i32
  %1237 = sext i32 %1236 to i64
  %1238 = call i64 @llvm.expect.i64(i64 %1237, i64 1)
  %1239 = icmp ne i64 %1238, 0
  br i1 %1239, label %1240, label %1257

1240:                                             ; preds = %1229
  br label %1241

1241:                                             ; preds = %1240
  %1242 = load ptr, ptr %6, align 8, !tbaa !5
  %1243 = getelementptr inbounds %struct.MDBX_cursor, ptr %1242, i32 0, i32 8
  %1244 = load ptr, ptr %1243, align 8, !tbaa !47
  %1245 = icmp ne ptr %1244, null
  %1246 = xor i1 %1245, true
  %1247 = xor i1 %1246, true
  %1248 = xor i1 %1247, true
  %1249 = zext i1 %1248 to i32
  %1250 = sext i32 %1249 to i64
  %1251 = call i64 @llvm.expect.i64(i64 %1250, i64 0)
  %1252 = icmp ne i64 %1251, 0
  br i1 %1252, label %1253, label %1254

1253:                                             ; preds = %1241
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.58, ptr noundef @__func__.cursor_seek, i32 noundef 1923) #10
  unreachable

1254:                                             ; preds = %1241
  br label %1255

1255:                                             ; preds = %1254
  br label %1256

1256:                                             ; preds = %1255
  br label %1257

1257:                                             ; preds = %1256, %1229
  br label %1258

1258:                                             ; preds = %1257
  br label %1259

1259:                                             ; preds = %1258
  %1260 = load ptr, ptr %15, align 8, !tbaa !5
  %1261 = call zeroext i8 @node_flags(ptr noundef %1260) #11
  %1262 = zext i8 %1261 to i32
  %1263 = and i32 %1262, 2
  %1264 = icmp ne i32 %1263, 0
  br i1 %1264, label %1265, label %1284

1265:                                             ; preds = %1259
  %1266 = load ptr, ptr %6, align 8, !tbaa !5
  %1267 = getelementptr inbounds %struct.MDBX_cursor, ptr %1266, i32 0, i32 8
  %1268 = load ptr, ptr %1267, align 8, !tbaa !47
  %1269 = getelementptr inbounds %struct.inner_cursor, ptr %1268, i32 0, i32 0
  %1270 = load ptr, ptr %8, align 8, !tbaa !5
  %1271 = call i32 @inner_first(ptr noundef %1269, ptr noundef %1270) #12
  %1272 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 %1271, ptr %1272, align 4, !tbaa !31
  %1273 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  %1274 = load i32, ptr %1273, align 4, !tbaa !31
  %1275 = icmp ne i32 %1274, 0
  %1276 = xor i1 %1275, true
  %1277 = xor i1 %1276, true
  %1278 = zext i1 %1277 to i32
  %1279 = sext i32 %1278 to i64
  %1280 = call i64 @llvm.expect.i64(i64 %1279, i64 0)
  %1281 = icmp ne i64 %1280, 0
  br i1 %1281, label %1282, label %1283

1282:                                             ; preds = %1265
  store i32 1, ptr %11, align 4
  br label %1730

1283:                                             ; preds = %1265
  br label %1371

1284:                                             ; preds = %1259
  %1285 = load ptr, ptr %8, align 8, !tbaa !5
  %1286 = icmp ne ptr %1285, null
  br i1 %1286, label %1287, label %1370

1287:                                             ; preds = %1284
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #9
  %1288 = load ptr, ptr %6, align 8, !tbaa !5
  %1289 = getelementptr inbounds %struct.MDBX_cursor, ptr %1288, i32 0, i32 8
  %1290 = load ptr, ptr %1289, align 8, !tbaa !47
  %1291 = getelementptr inbounds %struct.inner_cursor, ptr %1290, i32 0, i32 0
  %1292 = getelementptr inbounds %struct.MDBX_cursor, ptr %1291, i32 0, i32 9
  %1293 = getelementptr inbounds [32 x ptr], ptr %1292, i64 0, i64 0
  %1294 = load ptr, ptr %1293, align 8, !tbaa !5
  store ptr %1294, ptr %26, align 8, !tbaa !5
  br label %1295

1295:                                             ; preds = %1287
  %1296 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1297 = zext i8 %1296 to i32
  %1298 = and i32 %1297, 1
  %1299 = icmp ne i32 %1298, 0
  %1300 = xor i1 %1299, true
  %1301 = xor i1 %1300, true
  %1302 = zext i1 %1301 to i32
  %1303 = sext i32 %1302 to i64
  %1304 = call i64 @llvm.expect.i64(i64 %1303, i64 1)
  %1305 = icmp ne i64 %1304, 0
  br i1 %1305, label %1306, label %1331

1306:                                             ; preds = %1295
  br label %1307

1307:                                             ; preds = %1306
  %1308 = load ptr, ptr %26, align 8, !tbaa !5
  %1309 = call zeroext i1 @is_subpage(ptr noundef %1308) #11
  br i1 %1309, label %1310, label %1313

1310:                                             ; preds = %1307
  %1311 = load ptr, ptr %26, align 8, !tbaa !5
  %1312 = call zeroext i1 @is_leaf(ptr noundef %1311) #11
  br label %1313

1313:                                             ; preds = %1310, %1307
  %1314 = phi i1 [ false, %1307 ], [ %1312, %1310 ]
  %1315 = xor i1 %1314, true
  %1316 = xor i1 %1315, true
  %1317 = xor i1 %1316, true
  %1318 = zext i1 %1317 to i32
  %1319 = sext i32 %1318 to i64
  %1320 = call i64 @llvm.expect.i64(i64 %1319, i64 0)
  %1321 = icmp ne i64 %1320, 0
  br i1 %1321, label %1322, label %1328

1322:                                             ; preds = %1313
  %1323 = load ptr, ptr %6, align 8, !tbaa !5
  %1324 = getelementptr inbounds %struct.MDBX_cursor, ptr %1323, i32 0, i32 5
  %1325 = load ptr, ptr %1324, align 8, !tbaa !25
  %1326 = getelementptr inbounds %struct.MDBX_txn, ptr %1325, i32 0, i32 9
  %1327 = load ptr, ptr %1326, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %1327, ptr noundef @.str.113, ptr noundef @__func__.cursor_seek, i32 noundef 1930) #10
  unreachable

1328:                                             ; preds = %1313
  br label %1329

1329:                                             ; preds = %1328
  br label %1330

1330:                                             ; preds = %1329
  br label %1331

1331:                                             ; preds = %1330, %1295
  br label %1332

1332:                                             ; preds = %1331
  br label %1333

1333:                                             ; preds = %1332
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #9
  %1334 = load ptr, ptr %6, align 8, !tbaa !5
  %1335 = getelementptr inbounds %struct.MDBX_cursor, ptr %1334, i32 0, i32 8
  %1336 = load ptr, ptr %1335, align 8, !tbaa !47
  %1337 = getelementptr inbounds %struct.inner_cursor, ptr %1336, i32 0, i32 0
  %1338 = getelementptr inbounds %struct.MDBX_cursor, ptr %1337, i32 0, i32 10
  %1339 = getelementptr inbounds [32 x i16], ptr %1338, i64 0, i64 0
  %1340 = load i16, ptr %1339, align 8, !tbaa !42
  %1341 = zext i16 %1340 to i64
  store i64 %1341, ptr %27, align 8, !tbaa !33
  %1342 = load ptr, ptr %26, align 8, !tbaa !5
  %1343 = call zeroext i1 @is_dupfix_leaf(ptr noundef %1342) #11
  br i1 %1343, label %1344, label %1359

1344:                                             ; preds = %1333
  %1345 = load ptr, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %28) #9
  %1346 = load ptr, ptr %26, align 8, !tbaa !5
  %1347 = load i64, ptr %27, align 8, !tbaa !33
  %1348 = load ptr, ptr %6, align 8, !tbaa !5
  %1349 = getelementptr inbounds %struct.MDBX_cursor, ptr %1348, i32 0, i32 6
  %1350 = load ptr, ptr %1349, align 8, !tbaa !34
  %1351 = getelementptr inbounds %struct.tree, ptr %1350, i32 0, i32 2
  %1352 = load i32, ptr %1351, align 4, !tbaa !43
  %1353 = zext i32 %1352 to i64
  %1354 = call { ptr, i64 } @page_dupfix_key(ptr noundef %1346, i64 noundef %1347, i64 noundef %1353) #11
  %1355 = getelementptr inbounds { ptr, i64 }, ptr %28, i32 0, i32 0
  %1356 = extractvalue { ptr, i64 } %1354, 0
  store ptr %1356, ptr %1355, align 8
  %1357 = getelementptr inbounds { ptr, i64 }, ptr %28, i32 0, i32 1
  %1358 = extractvalue { ptr, i64 } %1354, 1
  store i64 %1358, ptr %1357, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1345, ptr align 8 %28, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.end.p0(i64 16, ptr %28) #9
  br label %1369

1359:                                             ; preds = %1333
  %1360 = load ptr, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %29) #9
  %1361 = load ptr, ptr %26, align 8, !tbaa !5
  %1362 = load i64, ptr %27, align 8, !tbaa !33
  %1363 = call ptr @page_node(ptr noundef %1361, i64 noundef %1362) #11
  %1364 = call { ptr, i64 } @get_key(ptr noundef %1363) #11
  %1365 = getelementptr inbounds { ptr, i64 }, ptr %29, i32 0, i32 0
  %1366 = extractvalue { ptr, i64 } %1364, 0
  store ptr %1366, ptr %1365, align 8
  %1367 = getelementptr inbounds { ptr, i64 }, ptr %29, i32 0, i32 1
  %1368 = extractvalue { ptr, i64 } %1364, 1
  store i64 %1368, ptr %1367, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1360, ptr align 8 %29, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.end.p0(i64 16, ptr %29) #9
  br label %1369

1369:                                             ; preds = %1359, %1344
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #9
  br label %1370

1370:                                             ; preds = %1369, %1284
  br label %1371

1371:                                             ; preds = %1370, %1283
  br label %1437

1372:                                             ; preds = %1225
  br label %1373

1373:                                             ; preds = %1372
  %1374 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1375 = zext i8 %1374 to i32
  %1376 = and i32 %1375, 1
  %1377 = icmp ne i32 %1376, 0
  %1378 = xor i1 %1377, true
  %1379 = xor i1 %1378, true
  %1380 = zext i1 %1379 to i32
  %1381 = sext i32 %1380 to i64
  %1382 = call i64 @llvm.expect.i64(i64 %1381, i64 1)
  %1383 = icmp ne i64 %1382, 0
  br i1 %1383, label %1384, label %1401

1384:                                             ; preds = %1373
  br label %1385

1385:                                             ; preds = %1384
  %1386 = load ptr, ptr %6, align 8, !tbaa !5
  %1387 = getelementptr inbounds %struct.MDBX_cursor, ptr %1386, i32 0, i32 8
  %1388 = load ptr, ptr %1387, align 8, !tbaa !47
  %1389 = icmp ne ptr %1388, null
  %1390 = xor i1 %1389, true
  %1391 = xor i1 %1390, true
  %1392 = xor i1 %1391, true
  %1393 = zext i1 %1392 to i32
  %1394 = sext i32 %1393 to i64
  %1395 = call i64 @llvm.expect.i64(i64 %1394, i64 0)
  %1396 = icmp ne i64 %1395, 0
  br i1 %1396, label %1397, label %1398

1397:                                             ; preds = %1385
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.58, ptr noundef @__func__.cursor_seek, i32 noundef 1938) #10
  unreachable

1398:                                             ; preds = %1385
  br label %1399

1399:                                             ; preds = %1398
  br label %1400

1400:                                             ; preds = %1399
  br label %1401

1401:                                             ; preds = %1400, %1373
  br label %1402

1402:                                             ; preds = %1401
  br label %1403

1403:                                             ; preds = %1402
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #9
  %1404 = load ptr, ptr %6, align 8, !tbaa !5
  %1405 = getelementptr inbounds %struct.MDBX_cursor, ptr %1404, i32 0, i32 8
  %1406 = load ptr, ptr %1405, align 8, !tbaa !47
  %1407 = getelementptr inbounds %struct.inner_cursor, ptr %1406, i32 0, i32 0
  %1408 = load ptr, ptr %8, align 8, !tbaa !5
  %1409 = call i64 @cursor_seek(ptr noundef %1407, ptr noundef %1408, ptr noundef null, i32 noundef 17) #12
  store i64 %1409, ptr %30, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 %30, i64 8, i1 false), !tbaa.struct !54
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #9
  %1410 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  %1411 = load i32, ptr %1410, align 4, !tbaa !31
  %1412 = icmp ne i32 %1411, 0
  %1413 = xor i1 %1412, true
  %1414 = xor i1 %1413, true
  %1415 = zext i1 %1414 to i32
  %1416 = sext i32 %1415 to i64
  %1417 = call i64 @llvm.expect.i64(i64 %1416, i64 0)
  %1418 = icmp ne i64 %1417, 0
  br i1 %1418, label %1419, label %1428

1419:                                             ; preds = %1403
  %1420 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  %1421 = load i32, ptr %1420, align 4, !tbaa !31
  %1422 = icmp eq i32 %1421, -30798
  br i1 %1422, label %1423, label %1427

1423:                                             ; preds = %1419
  %1424 = load i32, ptr %9, align 4, !tbaa !9
  %1425 = icmp ult i32 %1424, 17
  br i1 %1425, label %1426, label %1427

1426:                                             ; preds = %1423
  br label %600

1427:                                             ; preds = %1423, %1419
  store i32 1, ptr %11, align 4
  br label %1730

1428:                                             ; preds = %1403
  %1429 = load i32, ptr %9, align 4, !tbaa !9
  %1430 = icmp eq i32 %1429, 2
  br i1 %1430, label %1431, label %1436

1431:                                             ; preds = %1428
  %1432 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 1
  %1433 = load i8, ptr %1432, align 4, !tbaa !11, !range !51, !noundef !52
  %1434 = trunc i8 %1433 to i1
  br i1 %1434, label %1436, label %1435

1435:                                             ; preds = %1431
  br label %600

1436:                                             ; preds = %1431, %1428
  br label %1437

1437:                                             ; preds = %1436, %1371
  br label %1699

1438:                                             ; preds = %1203
  %1439 = load ptr, ptr %8, align 8, !tbaa !5
  %1440 = icmp ne ptr %1439, null
  %1441 = xor i1 %1440, true
  %1442 = xor i1 %1441, true
  %1443 = zext i1 %1442 to i32
  %1444 = sext i32 %1443 to i64
  %1445 = call i64 @llvm.expect.i64(i64 %1444, i64 1)
  %1446 = icmp ne i64 %1445, 0
  br i1 %1446, label %1447, label %1698

1447:                                             ; preds = %1438
  %1448 = load i32, ptr %9, align 4, !tbaa !9
  %1449 = icmp ule i32 %1448, 3
  br i1 %1449, label %1450, label %1671

1450:                                             ; preds = %1447
  %1451 = load ptr, ptr %8, align 8, !tbaa !5
  %1452 = getelementptr inbounds %struct.iovec, ptr %1451, i32 0, i32 1
  %1453 = load i64, ptr %1452, align 8, !tbaa !14
  %1454 = load ptr, ptr %6, align 8, !tbaa !5
  %1455 = getelementptr inbounds %struct.MDBX_cursor, ptr %1454, i32 0, i32 7
  %1456 = load ptr, ptr %1455, align 8, !tbaa !17
  %1457 = getelementptr inbounds %struct.clc2, ptr %1456, i32 0, i32 1
  %1458 = getelementptr inbounds %struct.clc, ptr %1457, i32 0, i32 1
  %1459 = load i64, ptr %1458, align 8, !tbaa !56
  %1460 = icmp ult i64 %1453, %1459
  br i1 %1460, label %1472, label %1461

1461:                                             ; preds = %1450
  %1462 = load ptr, ptr %8, align 8, !tbaa !5
  %1463 = getelementptr inbounds %struct.iovec, ptr %1462, i32 0, i32 1
  %1464 = load i64, ptr %1463, align 8, !tbaa !14
  %1465 = load ptr, ptr %6, align 8, !tbaa !5
  %1466 = getelementptr inbounds %struct.MDBX_cursor, ptr %1465, i32 0, i32 7
  %1467 = load ptr, ptr %1466, align 8, !tbaa !17
  %1468 = getelementptr inbounds %struct.clc2, ptr %1467, i32 0, i32 1
  %1469 = getelementptr inbounds %struct.clc, ptr %1468, i32 0, i32 2
  %1470 = load i64, ptr %1469, align 8, !tbaa !57
  %1471 = icmp ugt i64 %1464, %1470
  br label %1472

1472:                                             ; preds = %1461, %1450
  %1473 = phi i1 [ true, %1450 ], [ %1471, %1461 ]
  %1474 = xor i1 %1473, true
  %1475 = xor i1 %1474, true
  %1476 = zext i1 %1475 to i32
  %1477 = sext i32 %1476 to i64
  %1478 = call i64 @llvm.expect.i64(i64 %1477, i64 0)
  %1479 = icmp ne i64 %1478, 0
  br i1 %1479, label %1480, label %1505

1480:                                             ; preds = %1472
  br label %1481

1481:                                             ; preds = %1480
  %1482 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1483 = zext i8 %1482 to i32
  %1484 = and i32 %1483, 1
  %1485 = icmp ne i32 %1484, 0
  %1486 = xor i1 %1485, true
  %1487 = xor i1 %1486, true
  %1488 = zext i1 %1487 to i32
  %1489 = sext i32 %1488 to i64
  %1490 = call i64 @llvm.expect.i64(i64 %1489, i64 1)
  %1491 = icmp ne i64 %1490, 0
  br i1 %1491, label %1492, label %1501

1492:                                             ; preds = %1481
  br label %1493

1493:                                             ; preds = %1492
  %1494 = load ptr, ptr %6, align 8, !tbaa !5
  %1495 = getelementptr inbounds %struct.MDBX_cursor, ptr %1494, i32 0, i32 5
  %1496 = load ptr, ptr %1495, align 8, !tbaa !25
  %1497 = getelementptr inbounds %struct.MDBX_txn, ptr %1496, i32 0, i32 9
  %1498 = load ptr, ptr %1497, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %1498, ptr noundef @.str.92, ptr noundef @__func__.cursor_seek, i32 noundef 1951) #10
  unreachable

1499:                                             ; No predecessors!
  br label %1500

1500:                                             ; preds = %1499
  br label %1501

1501:                                             ; preds = %1500, %1481
  br label %1502

1502:                                             ; preds = %1501
  br label %1503

1503:                                             ; preds = %1502
  %1504 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30781, ptr %1504, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1730

1505:                                             ; preds = %1472
  call void @llvm.lifetime.start.p0(i64 16, ptr %31) #9
  %1506 = load ptr, ptr %8, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %31, ptr align 8 %1506, i64 16, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #9
  %1507 = load ptr, ptr %6, align 8, !tbaa !5
  %1508 = getelementptr inbounds %struct.MDBX_cursor, ptr %1507, i32 0, i32 6
  %1509 = load ptr, ptr %1508, align 8, !tbaa !34
  %1510 = getelementptr inbounds %struct.tree, ptr %1509, i32 0, i32 0
  %1511 = load i16, ptr %1510, align 4, !tbaa !35
  %1512 = zext i16 %1511 to i32
  %1513 = and i32 %1512, 32
  %1514 = icmp ne i32 %1513, 0
  br i1 %1514, label %1515, label %1586

1515:                                             ; preds = %1505
  %1516 = getelementptr inbounds %struct.iovec, ptr %31, i32 0, i32 1
  %1517 = load i64, ptr %1516, align 8, !tbaa !14
  %1518 = icmp eq i64 %1517, 8
  br i1 %1518, label %1519, label %1537

1519:                                             ; preds = %1515
  %1520 = getelementptr inbounds %struct.iovec, ptr %31, i32 0, i32 0
  %1521 = load ptr, ptr %1520, align 8, !tbaa !37
  %1522 = ptrtoint ptr %1521 to i64
  %1523 = and i64 7, %1522
  %1524 = icmp ne i64 %1523, 0
  %1525 = xor i1 %1524, true
  %1526 = xor i1 %1525, true
  %1527 = zext i1 %1526 to i32
  %1528 = sext i32 %1527 to i64
  %1529 = call i64 @llvm.expect.i64(i64 %1528, i64 0)
  %1530 = icmp ne i64 %1529, 0
  br i1 %1530, label %1531, label %1536

1531:                                             ; preds = %1519
  %1532 = getelementptr inbounds %struct.iovec, ptr %31, i32 0, i32 0
  %1533 = load ptr, ptr %1532, align 8, !tbaa !37
  %1534 = call ptr @bcopy_8(ptr noundef %32, ptr noundef %1533)
  %1535 = getelementptr inbounds %struct.iovec, ptr %31, i32 0, i32 0
  store ptr %1534, ptr %1535, align 8, !tbaa !37
  br label %1536

1536:                                             ; preds = %1531, %1519
  br label %1585

1537:                                             ; preds = %1515
  %1538 = getelementptr inbounds %struct.iovec, ptr %31, i32 0, i32 1
  %1539 = load i64, ptr %1538, align 8, !tbaa !14
  %1540 = icmp eq i64 %1539, 4
  br i1 %1540, label %1541, label %1559

1541:                                             ; preds = %1537
  %1542 = getelementptr inbounds %struct.iovec, ptr %31, i32 0, i32 0
  %1543 = load ptr, ptr %1542, align 8, !tbaa !37
  %1544 = ptrtoint ptr %1543 to i64
  %1545 = and i64 3, %1544
  %1546 = icmp ne i64 %1545, 0
  %1547 = xor i1 %1546, true
  %1548 = xor i1 %1547, true
  %1549 = zext i1 %1548 to i32
  %1550 = sext i32 %1549 to i64
  %1551 = call i64 @llvm.expect.i64(i64 %1550, i64 0)
  %1552 = icmp ne i64 %1551, 0
  br i1 %1552, label %1553, label %1558

1553:                                             ; preds = %1541
  %1554 = getelementptr inbounds %struct.iovec, ptr %31, i32 0, i32 0
  %1555 = load ptr, ptr %1554, align 8, !tbaa !37
  %1556 = call ptr @bcopy_4(ptr noundef %32, ptr noundef %1555)
  %1557 = getelementptr inbounds %struct.iovec, ptr %31, i32 0, i32 0
  store ptr %1556, ptr %1557, align 8, !tbaa !37
  br label %1558

1558:                                             ; preds = %1553, %1541
  br label %1584

1559:                                             ; preds = %1537
  br label %1560

1560:                                             ; preds = %1559
  %1561 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1562 = zext i8 %1561 to i32
  %1563 = and i32 %1562, 1
  %1564 = icmp ne i32 %1563, 0
  %1565 = xor i1 %1564, true
  %1566 = xor i1 %1565, true
  %1567 = zext i1 %1566 to i32
  %1568 = sext i32 %1567 to i64
  %1569 = call i64 @llvm.expect.i64(i64 %1568, i64 1)
  %1570 = icmp ne i64 %1569, 0
  br i1 %1570, label %1571, label %1580

1571:                                             ; preds = %1560
  br label %1572

1572:                                             ; preds = %1571
  %1573 = load ptr, ptr %6, align 8, !tbaa !5
  %1574 = getelementptr inbounds %struct.MDBX_cursor, ptr %1573, i32 0, i32 5
  %1575 = load ptr, ptr %1574, align 8, !tbaa !25
  %1576 = getelementptr inbounds %struct.MDBX_txn, ptr %1575, i32 0, i32 9
  %1577 = load ptr, ptr %1576, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %1577, ptr noundef @.str.114, ptr noundef @__func__.cursor_seek, i32 noundef 1967) #10
  unreachable

1578:                                             ; No predecessors!
  br label %1579

1579:                                             ; preds = %1578
  br label %1580

1580:                                             ; preds = %1579, %1560
  br label %1581

1581:                                             ; preds = %1580
  br label %1582

1582:                                             ; preds = %1581
  %1583 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30781, ptr %1583, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1668

1584:                                             ; preds = %1558
  br label %1585

1585:                                             ; preds = %1584, %1536
  br label %1586

1586:                                             ; preds = %1585, %1505
  call void @llvm.lifetime.start.p0(i64 16, ptr %33) #9
  %1587 = load ptr, ptr %6, align 8, !tbaa !5
  %1588 = load ptr, ptr %15, align 8, !tbaa !5
  %1589 = load ptr, ptr %6, align 8, !tbaa !5
  %1590 = getelementptr inbounds %struct.MDBX_cursor, ptr %1589, i32 0, i32 9
  %1591 = load ptr, ptr %6, align 8, !tbaa !5
  %1592 = getelementptr inbounds %struct.MDBX_cursor, ptr %1591, i32 0, i32 1
  %1593 = getelementptr inbounds %struct.anon, ptr %1592, i32 0, i32 1
  %1594 = load i8, ptr %1593, align 1, !tbaa !38
  %1595 = sext i8 %1594 to i64
  %1596 = getelementptr inbounds [32 x ptr], ptr %1590, i64 0, i64 %1595
  %1597 = load ptr, ptr %1596, align 8, !tbaa !5
  %1598 = call i32 @node_read(ptr noundef %1587, ptr noundef %1588, ptr noundef %33, ptr noundef %1597)
  %1599 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 %1598, ptr %1599, align 4, !tbaa !31
  %1600 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  %1601 = load i32, ptr %1600, align 4, !tbaa !31
  %1602 = icmp ne i32 %1601, 0
  %1603 = xor i1 %1602, true
  %1604 = xor i1 %1603, true
  %1605 = zext i1 %1604 to i32
  %1606 = sext i32 %1605 to i64
  %1607 = call i64 @llvm.expect.i64(i64 %1606, i64 0)
  %1608 = icmp ne i64 %1607, 0
  br i1 %1608, label %1609, label %1610

1609:                                             ; preds = %1586
  store i32 1, ptr %11, align 4
  br label %1667

1610:                                             ; preds = %1586
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #9
  %1611 = load ptr, ptr %6, align 8, !tbaa !5
  %1612 = getelementptr inbounds %struct.MDBX_cursor, ptr %1611, i32 0, i32 7
  %1613 = load ptr, ptr %1612, align 8, !tbaa !17
  %1614 = getelementptr inbounds %struct.clc2, ptr %1613, i32 0, i32 1
  %1615 = getelementptr inbounds %struct.clc, ptr %1614, i32 0, i32 0
  %1616 = load ptr, ptr %1615, align 8, !tbaa !58
  %1617 = call i32 %1616(ptr noundef %31, ptr noundef %33)
  store i32 %1617, ptr %34, align 4, !tbaa !9
  %1618 = load i32, ptr %34, align 4, !tbaa !9
  %1619 = icmp ne i32 %1618, 0
  br i1 %1619, label %1620, label %1664

1620:                                             ; preds = %1610
  %1621 = load i32, ptr %9, align 4, !tbaa !9
  %1622 = icmp ne i32 %1621, 3
  br i1 %1622, label %1623, label %1658

1623:                                             ; preds = %1620
  br label %1624

1624:                                             ; preds = %1623
  %1625 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !23
  %1626 = zext i8 %1625 to i32
  %1627 = and i32 %1626, 1
  %1628 = icmp ne i32 %1627, 0
  %1629 = xor i1 %1628, true
  %1630 = xor i1 %1629, true
  %1631 = zext i1 %1630 to i32
  %1632 = sext i32 %1631 to i64
  %1633 = call i64 @llvm.expect.i64(i64 %1632, i64 1)
  %1634 = icmp ne i64 %1633, 0
  br i1 %1634, label %1635, label %1655

1635:                                             ; preds = %1624
  br label %1636

1636:                                             ; preds = %1635
  %1637 = load i32, ptr %9, align 4, !tbaa !9
  %1638 = icmp eq i32 %1637, 2
  %1639 = xor i1 %1638, true
  %1640 = xor i1 %1639, true
  %1641 = xor i1 %1640, true
  %1642 = zext i1 %1641 to i32
  %1643 = sext i32 %1642 to i64
  %1644 = call i64 @llvm.expect.i64(i64 %1643, i64 0)
  %1645 = icmp ne i64 %1644, 0
  br i1 %1645, label %1646, label %1652

1646:                                             ; preds = %1636
  %1647 = load ptr, ptr %6, align 8, !tbaa !5
  %1648 = getelementptr inbounds %struct.MDBX_cursor, ptr %1647, i32 0, i32 5
  %1649 = load ptr, ptr %1648, align 8, !tbaa !25
  %1650 = getelementptr inbounds %struct.MDBX_txn, ptr %1649, i32 0, i32 9
  %1651 = load ptr, ptr %1650, align 8, !tbaa !26
  call void @mdbx_assert_fail(ptr noundef %1651, ptr noundef @.str.115, ptr noundef @__func__.cursor_seek, i32 noundef 1979) #10
  unreachable

1652:                                             ; preds = %1636
  br label %1653

1653:                                             ; preds = %1652
  br label %1654

1654:                                             ; preds = %1653
  br label %1655

1655:                                             ; preds = %1654, %1624
  br label %1656

1656:                                             ; preds = %1655
  br label %1657

1657:                                             ; preds = %1656
  store i32 28, ptr %11, align 4
  br label %1666

1658:                                             ; preds = %1620
  %1659 = load i32, ptr %34, align 4, !tbaa !9
  %1660 = icmp sgt i32 %1659, 0
  br i1 %1660, label %1661, label %1663

1661:                                             ; preds = %1658
  %1662 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 -30798, ptr %1662, align 4, !tbaa !31
  store i32 1, ptr %11, align 4
  br label %1666

1663:                                             ; preds = %1658
  br label %1664

1664:                                             ; preds = %1663, %1610
  %1665 = load ptr, ptr %8, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1665, ptr align 8 %33, i64 16, i1 false), !tbaa.struct !32
  store i32 0, ptr %11, align 4
  br label %1666

1666:                                             ; preds = %1664, %1661, %1657
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #9
  br label %1667

1667:                                             ; preds = %1666, %1609
  call void @llvm.lifetime.end.p0(i64 16, ptr %33) #9
  br label %1668

1668:                                             ; preds = %1667, %1582
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr %31) #9
  %1669 = load i32, ptr %11, align 4
  switch i32 %1669, label %1730 [
    i32 0, label %1670
    i32 28, label %600
  ]

1670:                                             ; preds = %1668
  br label %1697

1671:                                             ; preds = %1447
  %1672 = load ptr, ptr %6, align 8, !tbaa !5
  %1673 = load ptr, ptr %15, align 8, !tbaa !5
  %1674 = load ptr, ptr %8, align 8, !tbaa !5
  %1675 = load ptr, ptr %6, align 8, !tbaa !5
  %1676 = getelementptr inbounds %struct.MDBX_cursor, ptr %1675, i32 0, i32 9
  %1677 = load ptr, ptr %6, align 8, !tbaa !5
  %1678 = getelementptr inbounds %struct.MDBX_cursor, ptr %1677, i32 0, i32 1
  %1679 = getelementptr inbounds %struct.anon, ptr %1678, i32 0, i32 1
  %1680 = load i8, ptr %1679, align 1, !tbaa !38
  %1681 = sext i8 %1680 to i64
  %1682 = getelementptr inbounds [32 x ptr], ptr %1676, i64 0, i64 %1681
  %1683 = load ptr, ptr %1682, align 8, !tbaa !5
  %1684 = call i32 @node_read(ptr noundef %1672, ptr noundef %1673, ptr noundef %1674, ptr noundef %1683)
  %1685 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 %1684, ptr %1685, align 4, !tbaa !31
  %1686 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  %1687 = load i32, ptr %1686, align 4, !tbaa !31
  %1688 = icmp ne i32 %1687, 0
  %1689 = xor i1 %1688, true
  %1690 = xor i1 %1689, true
  %1691 = zext i1 %1690 to i32
  %1692 = sext i32 %1691 to i64
  %1693 = call i64 @llvm.expect.i64(i64 %1692, i64 0)
  %1694 = icmp ne i64 %1693, 0
  br i1 %1694, label %1695, label %1696

1695:                                             ; preds = %1671
  store i32 1, ptr %11, align 4
  br label %1730

1696:                                             ; preds = %1671
  br label %1697

1697:                                             ; preds = %1696, %1670
  br label %1698

1698:                                             ; preds = %1697, %1438
  br label %1699

1699:                                             ; preds = %1698, %1437
  %1700 = load i32, ptr %9, align 4, !tbaa !9
  %1701 = icmp uge i32 %1700, 16
  br i1 %1701, label %1702, label %1705

1702:                                             ; preds = %1699
  %1703 = load ptr, ptr %15, align 8, !tbaa !5
  %1704 = load ptr, ptr %7, align 8, !tbaa !5
  call void @get_key_optional(ptr noundef %1703, ptr noundef %1704)
  br label %1705

1705:                                             ; preds = %1702, %1699
  br label %1706

1706:                                             ; preds = %1705
  %1707 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !53
  %1708 = zext i8 %1707 to i32
  %1709 = icmp sle i32 5, %1708
  %1710 = xor i1 %1709, true
  %1711 = xor i1 %1710, true
  %1712 = zext i1 %1711 to i32
  %1713 = sext i32 %1712 to i64
  %1714 = call i64 @llvm.expect.i64(i64 %1713, i64 0)
  %1715 = icmp ne i64 %1714, 0
  br i1 %1715, label %1716, label %1725

1716:                                             ; preds = %1706
  %1717 = load ptr, ptr %7, align 8, !tbaa !5
  %1718 = getelementptr inbounds [510 x i8], ptr %10, i64 0, i64 0
  %1719 = call ptr @mdbx_dump_val(ptr noundef %1717, ptr noundef %1718, i64 noundef 255)
  %1720 = load ptr, ptr %8, align 8, !tbaa !5
  %1721 = getelementptr inbounds [510 x i8], ptr %10, i64 0, i64 0
  %1722 = getelementptr inbounds i8, ptr %1721, i64 254
  %1723 = getelementptr inbounds i8, ptr %1722, i64 1
  %1724 = call ptr @mdbx_dump_val(ptr noundef %1720, ptr noundef %1723, i64 noundef 255)
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.cursor_seek, i32 noundef 1999, ptr noundef @.str.116, ptr noundef %1719, ptr noundef %1724)
  br label %1725

1725:                                             ; preds = %1716, %1706
  br label %1726

1726:                                             ; preds = %1725
  br label %1727

1727:                                             ; preds = %1726
  %1728 = getelementptr inbounds %struct.cursor_set_result, ptr %5, i32 0, i32 0
  store i32 0, ptr %1728, align 4, !tbaa !31
  %1729 = load ptr, ptr %6, align 8, !tbaa !5
  call void @be_filled(ptr noundef %1729)
  store i32 1, ptr %11, align 4
  br label %1730

1730:                                             ; preds = %1727, %1695, %1668, %1503, %1427, %1282, %1224, %1200, %1168, %990, %785, %702, %666, %584, %317
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #9
  br label %1731

1731:                                             ; preds = %1730, %187
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr %12) #9
  br label %1732

1732:                                             ; preds = %1731, %108
  call void @llvm.lifetime.end.p0(i64 510, ptr %10) #9
  %1733 = load i64, ptr %5, align 4
  ret i64 %1733
}

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @bcopy_8(ptr noalias noundef, ptr noalias noundef) #8

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @bcopy_4(ptr noalias noundef, ptr noalias noundef) #8

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

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

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden { ptr, i64 } @page_dupfix_key(ptr noundef, i64 noundef, i64 noundef) #2

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden { ptr, i64 } @get_key(ptr noundef) #2

declare i32 @tree_search(ptr noundef, ptr noundef, i32 noundef) #6

declare { ptr, i8 } @node_search(ptr noundef, ptr noundef) #6

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @get_key_optional(ptr noundef, ptr noundef) #8

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(none) }
attributes #1 = { noreturn "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { 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 #3 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { 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 = { 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 #8 = { 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 #9 = { nounwind }
attributes #10 = { noreturn }
attributes #11 = { nounwind willreturn memory(read) }
attributes #12 = { hot }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !13, i64 4}
!12 = !{!"cursor_set_result", !10, i64 0, !13, i64 4}
!13 = !{!"_Bool", !7, i64 0}
!14 = !{!15, !16, i64 8}
!15 = !{!"iovec", !6, i64 0, !16, i64 8}
!16 = !{!"long", !7, i64 0}
!17 = !{!18, !6, i64 32}
!18 = !{!"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}
!19 = !{!20, !16, i64 8}
!20 = !{!"clc2", !21, i64 0, !21, i64 24}
!21 = !{!"clc", !6, i64 0, !16, i64 8, !16, i64 16}
!22 = !{!20, !16, i64 16}
!23 = !{!24, !7, i64 25}
!24 = !{!"libmdbx_globals", !7, i64 0, !10, i64 16, !10, i64 20, !7, i64 24, !7, i64 25, !7, i64 26, !13, i64 27, !10, i64 28, !7, i64 32, !7, i64 40, !16, i64 80, !6, i64 88}
!25 = !{!18, !6, i64 16}
!26 = !{!27, !6, i64 80}
!27 = !{!"MDBX_txn", !10, i64 0, !10, i64 4, !16, i64 8, !16, i64 16, !6, i64 24, !6, i64 32, !28, i64 40, !16, i64 64, !16, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112, !6, i64 120, !30, i64 128, !6, i64 160, !7, i64 168}
!28 = !{!"geo", !29, i64 0, !29, i64 2, !10, i64 4, !10, i64 8, !7, i64 12, !7, i64 16}
!29 = !{!"short", !7, i64 0}
!30 = !{!"MDBX_canary", !16, i64 0, !16, i64 8, !16, i64 16, !16, i64 24}
!31 = !{!12, !10, i64 0}
!32 = !{i64 0, i64 8, !5, i64 8, i64 8, !33}
!33 = !{!16, !16, i64 0}
!34 = !{!18, !6, i64 24}
!35 = !{!36, !29, i64 0}
!36 = !{!"tree", !29, i64 0, !29, i64 2, !10, i64 4, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !16, i64 24, !16, i64 32, !16, i64 40}
!37 = !{!15, !6, i64 0}
!38 = !{!7, !7, i64 0}
!39 = !{!36, !29, i64 2}
!40 = !{!36, !10, i64 12}
!41 = !{!36, !10, i64 16}
!42 = !{!29, !29, i64 0}
!43 = !{!36, !10, i64 4}
!44 = !{!20, !6, i64 0}
!45 = distinct !{!45, !46}
!46 = !{!"llvm.loop.mustprogress"}
!47 = !{!18, !6, i64 40}
!48 = !{!49, !6, i64 0}
!49 = !{!"node_search_result", !6, i64 0, !13, i64 8}
!50 = !{!49, !13, i64 8}
!51 = !{i8 0, i8 2}
!52 = !{}
!53 = !{!24, !7, i64 26}
!54 = !{i64 0, i64 4, !9, i64 4, i64 1, !55}
!55 = !{!13, !13, i64 0}
!56 = !{!20, !16, i64 32}
!57 = !{!20, !16, i64 40}
!58 = !{!20, !6, i64 24}


; 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 }
%struct.iovec = type { ptr, i64 }

@globals = external local_unnamed_addr global %struct.libmdbx_globals, align 8
@.str.54 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.91 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.92 = external hidden unnamed_addr constant [21 x i8], align 1
@.str.93 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.96 = external hidden unnamed_addr constant [51 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
@__func__.cursor_seek = external hidden unnamed_addr constant [12 x i8], align 1
@.str.105 = external hidden unnamed_addr constant [116 x i8], align 1
@.str.106 = external hidden unnamed_addr constant [27 x i8], align 1
@.str.107 = external hidden unnamed_addr constant [89 x i8], align 1
@.str.108 = external hidden unnamed_addr constant [21 x i8], align 1
@.str.109 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.110 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.111 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.112 = external hidden unnamed_addr constant [48 x i8], align 1
@.str.113 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.114 = external hidden unnamed_addr constant [44 x i8], align 1
@.str.115 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.116 = external hidden unnamed_addr constant [42 x i8], align 1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare ptr @mdbx_dump_val(ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #5

; Function Attrs: hot nounwind uwtable
define dso_local i64 @cursor_seek(ptr noundef %0, ptr noundef %1, ptr noundef %2, i32 noundef %3) local_unnamed_addr #6 {
  %5 = alloca [510 x i8], align 16
  %6 = alloca %struct.iovec, align 8
  %7 = alloca i64, align 8
  %8 = alloca %struct.iovec, align 8
  %9 = alloca %struct.iovec, align 8
  %10 = alloca i64, align 8
  %11 = alloca %struct.iovec, align 8
  call void @llvm.lifetime.start.p0(i64 510, ptr nonnull %5) #8
  %12 = getelementptr inbounds i8, ptr %1, i64 8
  %13 = load i64, ptr %12, align 8, !tbaa !5
  %14 = getelementptr inbounds i8, ptr %0, i64 32
  %15 = load ptr, ptr %14, align 8, !tbaa !11
  %16 = getelementptr inbounds i8, ptr %15, i64 8
  %17 = load i64, ptr %16, align 8, !tbaa !14
  %18 = icmp ult i64 %13, %17
  br i1 %18, label %.critedge, label %19, !prof !17

19:                                               ; preds = %4
  %20 = getelementptr inbounds i8, ptr %15, i64 16
  %21 = load i64, ptr %20, align 8, !tbaa !18
  %22 = icmp ugt i64 %13, %21
  br i1 %22, label %.critedge, label %30, !prof !17

.critedge:                                        ; preds = %4, %19
  %23 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %24 = and i8 %23, 1
  %.not302 = icmp eq i8 %24, 0
  br i1 %.not302, label %554, label %25, !prof !17

25:                                               ; preds = %.critedge
  %26 = getelementptr inbounds i8, ptr %0, i64 16
  %27 = load ptr, ptr %26, align 8, !tbaa !22
  %28 = getelementptr inbounds i8, ptr %27, i64 80
  %29 = load ptr, ptr %28, align 8, !tbaa !23
  tail call void @mdbx_assert_fail(ptr noundef %29, ptr noundef nonnull @.str.91, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1733) #9
  unreachable

30:                                               ; preds = %19
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %6) #8
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %6, ptr noundef nonnull align 8 dereferenceable(16) %1, i64 16, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %7) #8
  %31 = getelementptr inbounds i8, ptr %0, i64 24
  %32 = load ptr, ptr %31, align 8, !tbaa !31
  %33 = load i16, ptr %32, align 4, !tbaa !32
  %34 = and i16 %33, 8
  %.not = icmp eq i16 %34, 0
  br i1 %.not, label %58, label %35

35:                                               ; preds = %30
  %36 = getelementptr inbounds i8, ptr %6, i64 8
  %37 = load i64, ptr %36, align 8, !tbaa !5
  switch i64 %37, label %50 [
    i64 8, label %38
    i64 4, label %44
  ]

38:                                               ; preds = %35
  %39 = load ptr, ptr %6, align 8, !tbaa !34
  %40 = ptrtoint ptr %39 to i64
  %41 = and i64 %40, 7
  %.not256 = icmp eq i64 %41, 0
  br i1 %.not256, label %58, label %42, !prof !35

42:                                               ; preds = %38
  %43 = call ptr @bcopy_8(ptr noundef nonnull %7, ptr noundef %39)
  store ptr %43, ptr %6, align 8, !tbaa !34
  br label %58

44:                                               ; preds = %35
  %45 = load ptr, ptr %6, align 8, !tbaa !34
  %46 = ptrtoint ptr %45 to i64
  %47 = and i64 %46, 3
  %.not255 = icmp eq i64 %47, 0
  br i1 %.not255, label %58, label %48, !prof !35

48:                                               ; preds = %44
  %49 = call ptr @bcopy_4(ptr noundef nonnull %7, ptr noundef %45)
  store ptr %49, ptr %6, align 8, !tbaa !34
  br label %58

50:                                               ; preds = %35
  %51 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %52 = and i8 %51, 1
  %.not254 = icmp eq i8 %52, 0
  br i1 %.not254, label %552, label %53, !prof !17

53:                                               ; preds = %50
  %54 = getelementptr inbounds i8, ptr %0, i64 16
  %55 = load ptr, ptr %54, align 8, !tbaa !22
  %56 = getelementptr inbounds i8, ptr %55, i64 80
  %57 = load ptr, ptr %56, align 8, !tbaa !23
  tail call void @mdbx_assert_fail(ptr noundef %57, ptr noundef nonnull @.str.93, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1750) #9
  unreachable

58:                                               ; preds = %42, %38, %44, %48, %30
  %59 = call zeroext i1 @is_pointed(ptr noundef nonnull %0) #10
  br i1 %59, label %60, label %253

60:                                               ; preds = %58
  %61 = getelementptr inbounds i8, ptr %0, i64 48
  %62 = getelementptr inbounds i8, ptr %0, i64 4
  %63 = getelementptr inbounds i8, ptr %0, i64 5
  %64 = load i8, ptr %63, align 1, !tbaa !36
  %65 = sext i8 %64 to i64
  %66 = getelementptr inbounds [32 x ptr], ptr %61, i64 0, i64 %65
  %67 = load ptr, ptr %66, align 8, !tbaa !29
  %68 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %69 = and i8 %68, 1
  %.not257 = icmp eq i8 %69, 0
  br i1 %.not257, label %77, label %70, !prof !17

70:                                               ; preds = %60
  %71 = call zeroext i1 @is_leaf(ptr noundef %67) #10
  br i1 %71, label %.thread, label %72, !prof !35

72:                                               ; preds = %70
  %73 = getelementptr inbounds i8, ptr %0, i64 16
  %74 = load ptr, ptr %73, align 8, !tbaa !22
  %75 = getelementptr inbounds i8, ptr %74, i64 80
  %76 = load ptr, ptr %75, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %76, ptr noundef nonnull @.str.100, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1761) #9
  unreachable

77:                                               ; preds = %60
  %78 = call i64 @page_numkeys(ptr noundef %67) #10
  %79 = icmp eq i64 %78, 0
  br i1 %79, label %545, label %104, !prof !17

.thread:                                          ; preds = %70
  %80 = call i64 @page_numkeys(ptr noundef %67) #10
  %81 = icmp eq i64 %80, 0
  br i1 %81, label %82, label %104, !prof !17

82:                                               ; preds = %.thread
  %83 = icmp eq i8 %64, 0
  br i1 %83, label %84, label %.critedge304, !prof !35

84:                                               ; preds = %82
  %85 = load ptr, ptr %31, align 8, !tbaa !31
  %86 = getelementptr inbounds i8, ptr %85, i64 2
  %87 = load i16, ptr %86, align 2, !tbaa !37
  %88 = icmp eq i16 %87, 1
  br i1 %88, label %89, label %.critedge304, !prof !35

89:                                               ; preds = %84
  %90 = getelementptr inbounds i8, ptr %85, i64 12
  %91 = load i32, ptr %90, align 4, !tbaa !38
  %92 = icmp eq i32 %91, 0
  br i1 %92, label %93, label %.critedge304, !prof !35

93:                                               ; preds = %89
  %94 = getelementptr inbounds i8, ptr %85, i64 16
  %95 = load i32, ptr %94, align 4, !tbaa !39
  %96 = icmp eq i32 %95, 1
  br i1 %96, label %97, label %.critedge304, !prof !35

97:                                               ; preds = %93
  %98 = getelementptr inbounds i8, ptr %0, i64 304
  %99 = load i16, ptr %98, align 8, !tbaa !40
  %.not343 = icmp eq i16 %99, 0
  br i1 %.not343, label %545, label %.critedge304, !prof !35

.critedge304:                                     ; preds = %93, %89, %84, %82, %97
  %100 = getelementptr inbounds i8, ptr %0, i64 16
  %101 = load ptr, ptr %100, align 8, !tbaa !22
  %102 = getelementptr inbounds i8, ptr %101, i64 80
  %103 = load ptr, ptr %102, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %103, ptr noundef nonnull @.str.105, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1766) #9
  unreachable

104:                                              ; preds = %.thread, %77
  %105 = phi i64 [ %80, %.thread ], [ %78, %77 ]
  %106 = call zeroext i1 @is_dupfix_leaf(ptr noundef %67) #10
  br i1 %106, label %107, label %115

107:                                              ; preds = %104
  %108 = load ptr, ptr %31, align 8, !tbaa !31
  %109 = getelementptr inbounds i8, ptr %108, i64 4
  %110 = load i32, ptr %109, align 4, !tbaa !41
  %111 = zext i32 %110 to i64
  %112 = call { ptr, i64 } @page_dupfix_key(ptr noundef %67, i64 noundef 0, i64 noundef %111) #10
  %113 = extractvalue { ptr, i64 } %112, 0
  %114 = extractvalue { ptr, i64 } %112, 1
  store ptr %113, ptr %8, align 8, !tbaa !29
  %.sroa.435.0..sroa_idx = getelementptr inbounds i8, ptr %8, i64 8
  store i64 %114, ptr %.sroa.435.0..sroa_idx, align 8, !tbaa !30
  br label %120

115:                                              ; preds = %104
  %116 = call ptr @page_node(ptr noundef %67, i64 noundef 0) #10
  %117 = call { ptr, i64 } @get_key(ptr noundef %116) #10
  %118 = extractvalue { ptr, i64 } %117, 0
  %119 = extractvalue { ptr, i64 } %117, 1
  store ptr %118, ptr %8, align 8, !tbaa !29
  %.sroa.433.0..sroa_idx = getelementptr inbounds i8, ptr %8, i64 8
  store i64 %119, ptr %.sroa.433.0..sroa_idx, align 8, !tbaa !30
  call void @inner_gone(ptr noundef nonnull %0)
  br label %120

120:                                              ; preds = %115, %107
  %.0226 = phi ptr [ null, %107 ], [ %116, %115 ]
  %121 = load ptr, ptr %14, align 8, !tbaa !11
  %122 = load ptr, ptr %121, align 8, !tbaa !42
  %123 = call i32 %122(ptr noundef nonnull %6, ptr noundef nonnull %8) #8
  %124 = icmp eq i32 %123, 0
  br i1 %124, label %125, label %130, !prof !17

125:                                              ; preds = %120
  %126 = getelementptr inbounds i8, ptr %0, i64 304
  %127 = load i8, ptr %63, align 1, !tbaa !36
  %128 = sext i8 %127 to i64
  %129 = getelementptr inbounds [32 x i16], ptr %126, i64 0, i64 %128
  store i16 0, ptr %129, align 2, !tbaa !40
  br label %343

130:                                              ; preds = %120
  %131 = icmp sgt i32 %123, 0
  br i1 %131, label %132, label %247

132:                                              ; preds = %130
  %.not259 = icmp eq i64 %105, 1
  br i1 %.not259, label %185, label %133, !prof !17

133:                                              ; preds = %132
  %134 = call zeroext i1 @is_dupfix_leaf(ptr noundef %67) #10
  %135 = add i64 %105, -1
  br i1 %134, label %136, label %140

136:                                              ; preds = %133
  %137 = getelementptr inbounds i8, ptr %8, i64 8
  %138 = load i64, ptr %137, align 8, !tbaa !5
  %139 = call ptr @page_dupfix_ptr(ptr noundef %67, i64 noundef %135, i64 noundef %138) #10
  br label %145

140:                                              ; preds = %133
  %141 = call ptr @page_node(ptr noundef %67, i64 noundef %135) #10
  %142 = call { ptr, i64 } @get_key(ptr noundef %141) #10
  %143 = extractvalue { ptr, i64 } %142, 0
  %144 = extractvalue { ptr, i64 } %142, 1
  %.sroa.426.0..sroa_idx = getelementptr inbounds i8, ptr %8, i64 8
  store i64 %144, ptr %.sroa.426.0..sroa_idx, align 8, !tbaa !30
  br label %145

145:                                              ; preds = %140, %136
  %.sink = phi ptr [ %139, %136 ], [ %143, %140 ]
  %.1227 = phi ptr [ %.0226, %136 ], [ %141, %140 ]
  store ptr %.sink, ptr %8, align 8
  %146 = load ptr, ptr %14, align 8, !tbaa !11
  %147 = load ptr, ptr %146, align 8, !tbaa !42
  %148 = call i32 %147(ptr noundef nonnull %6, ptr noundef nonnull %8) #8
  %149 = icmp eq i32 %148, 0
  br i1 %149, label %150, label %157

150:                                              ; preds = %145
  %151 = trunc i64 %105 to i16
  %152 = add i16 %151, -1
  %153 = getelementptr inbounds i8, ptr %0, i64 304
  %154 = load i8, ptr %63, align 1, !tbaa !36
  %155 = sext i8 %154 to i64
  %156 = getelementptr inbounds [32 x i16], ptr %153, i64 0, i64 %155
  store i16 %152, ptr %156, align 2, !tbaa !40
  br label %343

157:                                              ; preds = %145
  %158 = icmp slt i32 %148, 0
  br i1 %158, label %159, label %185

159:                                              ; preds = %157
  %160 = getelementptr inbounds i8, ptr %0, i64 304
  %161 = load i8, ptr %63, align 1, !tbaa !36
  %162 = sext i8 %161 to i64
  %163 = getelementptr inbounds [32 x i16], ptr %160, i64 0, i64 %162
  %164 = load i16, ptr %163, align 2, !tbaa !40
  %.not269 = icmp eq i16 %164, 0
  br i1 %.not269, label %296, label %165

165:                                              ; preds = %159
  %166 = zext i16 %164 to i64
  %167 = add i64 %105, -1
  %168 = icmp ugt i64 %167, %166
  br i1 %168, label %169, label %296

169:                                              ; preds = %165
  %170 = call zeroext i1 @is_dupfix_leaf(ptr noundef %67) #10
  br i1 %170, label %171, label %175

171:                                              ; preds = %169
  %172 = getelementptr inbounds i8, ptr %8, i64 8
  %173 = load i64, ptr %172, align 8, !tbaa !5
  %174 = call ptr @page_dupfix_ptr(ptr noundef %67, i64 noundef %166, i64 noundef %173) #10
  br label %180

175:                                              ; preds = %169
  %176 = call ptr @page_node(ptr noundef %67, i64 noundef %166) #10
  %177 = call { ptr, i64 } @get_key(ptr noundef %176) #10
  %178 = extractvalue { ptr, i64 } %177, 0
  %179 = extractvalue { ptr, i64 } %177, 1
  %.sroa.424.0..sroa_idx = getelementptr inbounds i8, ptr %8, i64 8
  store i64 %179, ptr %.sroa.424.0..sroa_idx, align 8, !tbaa !30
  br label %180

180:                                              ; preds = %175, %171
  %.sink346 = phi ptr [ %174, %171 ], [ %178, %175 ]
  %.2228 = phi ptr [ %.1227, %171 ], [ %176, %175 ]
  store ptr %.sink346, ptr %8, align 8
  %181 = load ptr, ptr %14, align 8, !tbaa !11
  %182 = load ptr, ptr %181, align 8, !tbaa !42
  %183 = call i32 %182(ptr noundef nonnull %6, ptr noundef nonnull %8) #8
  %184 = icmp eq i32 %183, 0
  br i1 %184, label %343, label %296

185:                                              ; preds = %132, %157
  %186 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %187 = and i8 %186, 1
  %.not260 = icmp eq i8 %187, 0
  %.pre = load i8, ptr %63, align 1, !tbaa !36
  br i1 %.not260, label %199, label %188, !prof !17

188:                                              ; preds = %185
  %189 = load ptr, ptr %31, align 8, !tbaa !31
  %190 = getelementptr inbounds i8, ptr %189, i64 2
  %191 = load i16, ptr %190, align 2, !tbaa !37
  %192 = zext i16 %191 to i32
  %193 = sext i8 %.pre to i32
  %.not261 = icmp sgt i32 %192, %193
  br i1 %.not261, label %199, label %194, !prof !35

194:                                              ; preds = %188
  %195 = getelementptr inbounds i8, ptr %0, i64 16
  %196 = load ptr, ptr %195, align 8, !tbaa !22
  %197 = getelementptr inbounds i8, ptr %196, i64 80
  %198 = load ptr, ptr %197, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %198, ptr noundef nonnull @.str.106, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1833) #9
  unreachable

199:                                              ; preds = %188, %185
  %200 = sext i8 %.pre to i64
  %201 = icmp sgt i8 %.pre, 0
  br i1 %201, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %199
  %202 = getelementptr inbounds i8, ptr %0, i64 304
  br label %205

203:                                              ; preds = %205
  %204 = add nuw nsw i64 %.0230345, 1
  %exitcond.not = icmp eq i64 %204, %200
  br i1 %exitcond.not, label %._crit_edge, label %205, !llvm.loop !43

205:                                              ; preds = %.lr.ph, %203
  %.0230345 = phi i64 [ 0, %.lr.ph ], [ %204, %203 ]
  %206 = getelementptr inbounds [32 x i16], ptr %202, i64 0, i64 %.0230345
  %207 = load i16, ptr %206, align 2, !tbaa !40
  %208 = zext i16 %207 to i64
  %209 = add nuw nsw i64 %208, 1
  %210 = getelementptr inbounds [32 x ptr], ptr %61, i64 0, i64 %.0230345
  %211 = load ptr, ptr %210, align 8, !tbaa !29
  %212 = call i64 @page_numkeys(ptr noundef %211) #10
  %213 = icmp ult i64 %209, %212
  br i1 %213, label %.loopexit, label %203

._crit_edge:                                      ; preds = %203, %199
  %214 = trunc i64 %105 to i16
  %215 = getelementptr inbounds i8, ptr %0, i64 304
  %216 = getelementptr inbounds [32 x i16], ptr %215, i64 0, i64 %200
  store i16 %214, ptr %216, align 2, !tbaa !40
  %217 = icmp ult i32 %3, 17
  br i1 %217, label %218, label %237

218:                                              ; preds = %524, %._crit_edge347, %454, %313, %250, %._crit_edge
  %.sroa.27.0 = phi i8 [ %.sroa.27.0.extract.trunc, %454 ], [ %.sroa.27.1, %524 ], [ %312, %313 ], [ 0, %._crit_edge ], [ 0, %250 ], [ %.sroa.27.0.extract.trunc, %._crit_edge347 ]
  %.sroa.34.sroa.0.0 = phi i64 [ %.sroa.34.0.extract.shift, %454 ], [ 0, %524 ], [ 0, %313 ], [ 0, %._crit_edge ], [ 0, %250 ], [ %.sroa.34.0.extract.shift, %._crit_edge347 ]
  %219 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %220 = and i8 %219, 1
  %.not293 = icmp eq i8 %220, 0
  br i1 %.not293, label %.critedge306, label %221, !prof !17

221:                                              ; preds = %218
  switch i32 %3, label %222 [
    i32 16, label %.critedge306
    i32 15, label %.critedge306
    i32 2, label %.critedge306
    i32 3, label %.critedge306
  ]

222:                                              ; preds = %221
  %223 = getelementptr inbounds i8, ptr %0, i64 16
  %224 = load ptr, ptr %223, align 8, !tbaa !22
  %225 = getelementptr inbounds i8, ptr %224, i64 80
  %226 = load ptr, ptr %225, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %226, ptr noundef nonnull @.str.107, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1842) #9
  unreachable

.critedge306:                                     ; preds = %221, %221, %221, %221, %218
  %227 = getelementptr inbounds i8, ptr %0, i64 4
  %228 = load i8, ptr %227, align 4, !tbaa !36
  %229 = or i8 %228, -128
  store i8 %229, ptr %227, align 4, !tbaa !36
  %230 = call zeroext i1 @inner_pointed(ptr noundef nonnull %0) #10
  br i1 %230, label %231, label %545

231:                                              ; preds = %.critedge306
  %232 = getelementptr inbounds i8, ptr %0, i64 40
  %233 = load ptr, ptr %232, align 8, !tbaa !45
  %234 = getelementptr inbounds i8, ptr %233, i64 4
  %235 = load i8, ptr %234, align 4, !tbaa !36
  %236 = or i8 %235, -128
  store i8 %236, ptr %234, align 4, !tbaa !36
  br label %545

237:                                              ; preds = %._crit_edge
  %.not268 = icmp eq i32 %3, 17
  %or.cond = or i1 %.not268, %.not260
  br i1 %or.cond, label %243, label %238, !prof !46

238:                                              ; preds = %237
  %239 = getelementptr inbounds i8, ptr %0, i64 16
  %240 = load ptr, ptr %239, align 8, !tbaa !22
  %241 = getelementptr inbounds i8, ptr %240, i64 80
  %242 = load ptr, ptr %241, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %242, ptr noundef nonnull @.str.108, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1853) #9
  unreachable

243:                                              ; preds = %237
  %244 = load i8, ptr %62, align 4, !tbaa !36
  %245 = and i8 %244, 3
  %246 = or disjoint i8 %245, 96
  store i8 %246, ptr %62, align 4, !tbaa !36
  br label %545

247:                                              ; preds = %130
  %248 = load i8, ptr %63, align 1, !tbaa !36
  %249 = icmp eq i8 %248, 0
  br i1 %249, label %250, label %253

250:                                              ; preds = %247
  %251 = getelementptr inbounds i8, ptr %0, i64 304
  store i16 0, ptr %251, align 2, !tbaa !40
  %252 = icmp ugt i32 %3, 16
  br i1 %252, label %343, label %218

253:                                              ; preds = %58, %247
  %254 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %255 = and i8 %254, 1
  %.not258 = icmp eq i8 %255, 0
  br i1 %.not258, label %.loopexit, label %256, !prof !17

256:                                              ; preds = %253
  %257 = call zeroext i1 @inner_pointed(ptr noundef nonnull %0) #10
  br i1 %257, label %258, label %.loopexit, !prof !17

258:                                              ; preds = %256
  %259 = getelementptr inbounds i8, ptr %0, i64 16
  %260 = load ptr, ptr %259, align 8, !tbaa !22
  %261 = getelementptr inbounds i8, ptr %260, i64 80
  %262 = load ptr, ptr %261, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %262, ptr noundef nonnull @.str.99, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1868) #9
  unreachable

.loopexit:                                        ; preds = %205, %253, %256
  %263 = call i32 @tree_search(ptr noundef nonnull %0, ptr noundef nonnull %6, i32 noundef 0) #8
  %.not262 = icmp eq i32 %263, 0
  br i1 %.not262, label %264, label %545, !prof !35

264:                                              ; preds = %.loopexit
  %265 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %266 = and i8 %265, 1
  %.not263 = icmp eq i8 %266, 0
  br i1 %.not263, label %.thread326, label %273, !prof !17

.thread326:                                       ; preds = %264
  %267 = getelementptr inbounds i8, ptr %0, i64 48
  %268 = getelementptr inbounds i8, ptr %0, i64 5
  %269 = load i8, ptr %268, align 1, !tbaa !36
  %270 = sext i8 %269 to i64
  %271 = getelementptr inbounds [32 x ptr], ptr %267, i64 0, i64 %270
  %272 = load ptr, ptr %271, align 8, !tbaa !29
  br label %296

273:                                              ; preds = %264
  %274 = call zeroext i1 @is_pointed(ptr noundef nonnull %0) #10
  br i1 %274, label %275, label %.critedge308, !prof !35

275:                                              ; preds = %273
  %276 = call zeroext i1 @inner_pointed(ptr noundef nonnull %0) #10
  br i1 %276, label %.critedge308, label %281, !prof !17

.critedge308:                                     ; preds = %273, %275
  %277 = getelementptr inbounds i8, ptr %0, i64 16
  %278 = load ptr, ptr %277, align 8, !tbaa !22
  %279 = getelementptr inbounds i8, ptr %278, i64 80
  %280 = load ptr, ptr %279, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %280, ptr noundef nonnull @.str.109, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1875) #9
  unreachable

281:                                              ; preds = %275
  %282 = getelementptr inbounds i8, ptr %0, i64 48
  %283 = getelementptr inbounds i8, ptr %0, i64 5
  %284 = load i8, ptr %283, align 1, !tbaa !36
  %285 = sext i8 %284 to i64
  %286 = getelementptr inbounds [32 x ptr], ptr %282, i64 0, i64 %285
  %287 = load ptr, ptr %286, align 8, !tbaa !29
  %.not265 = icmp eq ptr %287, null
  br i1 %.not265, label %288, label %289, !prof !47

288:                                              ; preds = %281
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.110, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1877) #9
  unreachable

289:                                              ; preds = %281
  %290 = call zeroext i1 @is_leaf(ptr noundef nonnull %287) #10
  br i1 %290, label %296, label %291, !prof !35

291:                                              ; preds = %289
  %292 = getelementptr inbounds i8, ptr %0, i64 16
  %293 = load ptr, ptr %292, align 8, !tbaa !22
  %294 = getelementptr inbounds i8, ptr %293, i64 80
  %295 = load ptr, ptr %294, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %295, ptr noundef nonnull @.str.100, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1878) #9
  unreachable

296:                                              ; preds = %.thread326, %180, %165, %159, %289
  %.0224 = phi ptr [ %67, %180 ], [ %67, %165 ], [ %67, %159 ], [ %287, %289 ], [ %272, %.thread326 ]
  %297 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %298 = and i8 %297, 1
  %.not270 = icmp eq i8 %298, 0
  br i1 %.not270, label %307, label %299, !prof !17

299:                                              ; preds = %296
  %300 = call zeroext i1 @is_pointed(ptr noundef nonnull %0) #10
  br i1 %300, label %301, label %.critedge311, !prof !35

301:                                              ; preds = %299
  %302 = call zeroext i1 @inner_pointed(ptr noundef nonnull %0) #10
  br i1 %302, label %.critedge311, label %307, !prof !17

.critedge311:                                     ; preds = %299, %301
  %303 = getelementptr inbounds i8, ptr %0, i64 16
  %304 = load ptr, ptr %303, align 8, !tbaa !22
  %305 = getelementptr inbounds i8, ptr %304, i64 80
  %306 = load ptr, ptr %305, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %306, ptr noundef nonnull @.str.109, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1881) #9
  unreachable

307:                                              ; preds = %301, %296
  %308 = call { ptr, i8 } @node_search(ptr noundef nonnull %0, ptr noundef nonnull %6) #8
  %309 = extractvalue { ptr, i8 } %308, 0
  %310 = extractvalue { ptr, i8 } %308, 1
  %311 = trunc i8 %310 to i1
  %312 = and i8 %310, 1
  br i1 %311, label %343, label %313

313:                                              ; preds = %307
  %314 = icmp ult i32 %3, 17
  br i1 %314, label %218, label %315

315:                                              ; preds = %313
  %316 = icmp eq ptr %309, null
  br i1 %316, label %317, label %343

317:                                              ; preds = %315
  %318 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !48
  %319 = icmp ugt i8 %318, 4
  br i1 %319, label %320, label %321, !prof !17

320:                                              ; preds = %317
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1890, ptr noundef nonnull @.str.54, ptr noundef nonnull @.str.111) #8
  br label %321

321:                                              ; preds = %320, %317
  %322 = call i32 @cursor_sibling_right(ptr noundef nonnull %0) #11
  %.not271 = icmp eq i32 %322, 0
  br i1 %.not271, label %323, label %545, !prof !35

323:                                              ; preds = %321
  %324 = getelementptr inbounds i8, ptr %0, i64 48
  %325 = getelementptr inbounds i8, ptr %0, i64 5
  %326 = load i8, ptr %325, align 1, !tbaa !36
  %327 = sext i8 %326 to i64
  %328 = getelementptr inbounds [32 x ptr], ptr %324, i64 0, i64 %327
  %329 = load ptr, ptr %328, align 8, !tbaa !29
  %330 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %331 = and i8 %330, 1
  %.not272 = icmp eq i8 %331, 0
  br i1 %.not272, label %339, label %332, !prof !17

332:                                              ; preds = %323
  %333 = call zeroext i1 @is_leaf(ptr noundef %329) #10
  br i1 %333, label %339, label %334, !prof !35

334:                                              ; preds = %332
  %335 = getelementptr inbounds i8, ptr %0, i64 16
  %336 = load ptr, ptr %335, align 8, !tbaa !22
  %337 = getelementptr inbounds i8, ptr %336, i64 80
  %338 = load ptr, ptr %337, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %338, ptr noundef nonnull @.str.100, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1895) #9
  unreachable

339:                                              ; preds = %332, %323
  %340 = call zeroext i1 @is_dupfix_leaf(ptr noundef %329) #10
  br i1 %340, label %343, label %341

341:                                              ; preds = %339
  %342 = call ptr @page_node(ptr noundef %329, i64 noundef 0) #10
  br label %343

343:                                              ; preds = %180, %125, %150, %250, %315, %341, %339, %307
  %.3229 = phi ptr [ %.0226, %125 ], [ %.1227, %150 ], [ %309, %307 ], [ null, %339 ], [ %342, %341 ], [ %309, %315 ], [ %.0226, %250 ], [ %.2228, %180 ]
  %.1225 = phi ptr [ %67, %125 ], [ %67, %150 ], [ %.0224, %307 ], [ %329, %339 ], [ %329, %341 ], [ %.0224, %315 ], [ %67, %250 ], [ %67, %180 ]
  %.sroa.27.1 = phi i8 [ 1, %125 ], [ 1, %150 ], [ %312, %307 ], [ %312, %339 ], [ %312, %341 ], [ %312, %315 ], [ 0, %250 ], [ 1, %180 ]
  %344 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %345 = and i8 %344, 1
  %.not273 = icmp eq i8 %345, 0
  br i1 %.not273, label %.thread327, label %346, !prof !17

346:                                              ; preds = %343
  %347 = call zeroext i1 @is_pointed(ptr noundef nonnull %0) #10
  br i1 %347, label %348, label %.critedge313, !prof !35

348:                                              ; preds = %346
  %349 = call zeroext i1 @inner_pointed(ptr noundef nonnull %0) #10
  br i1 %349, label %.critedge313, label %354, !prof !17

.critedge313:                                     ; preds = %346, %348
  %350 = getelementptr inbounds i8, ptr %0, i64 16
  %351 = load ptr, ptr %350, align 8, !tbaa !22
  %352 = getelementptr inbounds i8, ptr %351, i64 80
  %353 = load ptr, ptr %352, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %353, ptr noundef nonnull @.str.109, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1902) #9
  unreachable

354:                                              ; preds = %348
  %355 = getelementptr inbounds i8, ptr %0, i64 304
  %356 = getelementptr inbounds i8, ptr %0, i64 5
  %357 = load i8, ptr %356, align 1, !tbaa !36
  %358 = sext i8 %357 to i64
  %359 = getelementptr inbounds [32 x i16], ptr %355, i64 0, i64 %358
  %360 = load i16, ptr %359, align 2, !tbaa !40
  %361 = zext i16 %360 to i64
  %362 = getelementptr inbounds i8, ptr %0, i64 48
  %363 = getelementptr inbounds [32 x ptr], ptr %362, i64 0, i64 %358
  %364 = load ptr, ptr %363, align 8, !tbaa !29
  %365 = call i64 @page_numkeys(ptr noundef %364) #10
  %.not275 = icmp ugt i64 %365, %361
  br i1 %.not275, label %.thread327, label %366, !prof !35

366:                                              ; preds = %354
  %367 = getelementptr inbounds i8, ptr %0, i64 16
  %368 = load ptr, ptr %367, align 8, !tbaa !22
  %369 = getelementptr inbounds i8, ptr %368, i64 80
  %370 = load ptr, ptr %369, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %370, ptr noundef nonnull @.str.112, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1903) #9
  unreachable

.thread327:                                       ; preds = %343, %354
  %371 = call zeroext i1 @check_leaf_type(ptr noundef nonnull %0, ptr noundef %.1225) #10
  br i1 %371, label %380, label %372, !prof !35

372:                                              ; preds = %.thread327
  %373 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !48
  %.not300 = icmp eq i8 %373, 0
  br i1 %.not300, label %545, label %374, !prof !35

374:                                              ; preds = %372
  %375 = getelementptr inbounds i8, ptr %.1225, i64 16
  %376 = load i32, ptr %375, align 1, !tbaa !49
  %377 = getelementptr inbounds i8, ptr %.1225, i64 10
  %378 = load i16, ptr %377, align 1, !tbaa !40
  %379 = zext i16 %378 to i32
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 1, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1905, ptr noundef nonnull @.str.96, i32 noundef %376, i32 noundef %379) #8
  br label %545

380:                                              ; preds = %.thread327
  %381 = call zeroext i1 @is_dupfix_leaf(ptr noundef %.1225) #10
  br i1 %381, label %382, label %400

382:                                              ; preds = %380
  %383 = icmp ugt i32 %3, 15
  br i1 %383, label %384, label %399

384:                                              ; preds = %382
  %385 = getelementptr inbounds i8, ptr %0, i64 304
  %386 = getelementptr inbounds i8, ptr %0, i64 5
  %387 = load i8, ptr %386, align 1, !tbaa !36
  %388 = sext i8 %387 to i64
  %389 = getelementptr inbounds [32 x i16], ptr %385, i64 0, i64 %388
  %390 = load i16, ptr %389, align 2, !tbaa !40
  %391 = zext i16 %390 to i64
  %392 = load ptr, ptr %31, align 8, !tbaa !31
  %393 = getelementptr inbounds i8, ptr %392, i64 4
  %394 = load i32, ptr %393, align 4, !tbaa !41
  %395 = zext i32 %394 to i64
  %396 = call { ptr, i64 } @page_dupfix_key(ptr noundef %.1225, i64 noundef %391, i64 noundef %395) #10
  %397 = extractvalue { ptr, i64 } %396, 0
  %398 = extractvalue { ptr, i64 } %396, 1
  store ptr %397, ptr %1, align 8, !tbaa !29
  store i64 %398, ptr %12, align 8, !tbaa !30
  br label %399

399:                                              ; preds = %384, %382
  call void @be_filled(ptr noundef nonnull %0)
  br label %545

400:                                              ; preds = %380
  %401 = call zeroext i8 @node_flags(ptr noundef %.3229) #10
  %402 = and i8 %401, 4
  %.not276 = icmp eq i8 %402, 0
  br i1 %.not276, label %456, label %403

403:                                              ; preds = %400
  %404 = call i32 @cursor_dupsort_setup(ptr noundef nonnull %0, ptr noundef %.3229, ptr noundef %.1225)
  %.not289 = icmp eq i32 %404, 0
  br i1 %.not289, label %405, label %545, !prof !35

405:                                              ; preds = %403
  %406 = icmp ugt i32 %3, 14
  %407 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %408 = and i8 %407, 1
  %.not294 = icmp ne i8 %408, 0
  br i1 %406, label %409, label %449

409:                                              ; preds = %405
  br i1 %.not294, label %410, label %414, !prof !35

410:                                              ; preds = %409
  %411 = getelementptr inbounds i8, ptr %0, i64 40
  %412 = load ptr, ptr %411, align 8, !tbaa !45
  %.not295 = icmp eq ptr %412, null
  br i1 %.not295, label %413, label %414, !prof !17

413:                                              ; preds = %410
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.58, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1923) #9
  unreachable

414:                                              ; preds = %410, %409
  %415 = call zeroext i8 @node_flags(ptr noundef %.3229) #10
  %416 = and i8 %415, 2
  %.not296 = icmp eq i8 %416, 0
  br i1 %.not296, label %421, label %417

417:                                              ; preds = %414
  %418 = getelementptr inbounds i8, ptr %0, i64 40
  %419 = load ptr, ptr %418, align 8, !tbaa !45
  %420 = call i32 @inner_first(ptr noundef %419, ptr noundef %2) #11
  %.not299 = icmp eq i32 %420, 0
  br i1 %.not299, label %535, label %545, !prof !35

421:                                              ; preds = %414
  %.not297 = icmp eq ptr %2, null
  br i1 %.not297, label %535, label %422

422:                                              ; preds = %421
  %423 = getelementptr inbounds i8, ptr %0, i64 40
  %424 = load ptr, ptr %423, align 8, !tbaa !45
  %425 = getelementptr inbounds i8, ptr %424, i64 48
  %426 = load ptr, ptr %425, align 8, !tbaa !29
  br i1 %.not294, label %427, label %435, !prof !35

427:                                              ; preds = %422
  %428 = call zeroext i1 @is_subpage(ptr noundef %426) #10
  br i1 %428, label %429, label %.critedge315, !prof !35

429:                                              ; preds = %427
  %430 = call zeroext i1 @is_leaf(ptr noundef %426) #10
  br i1 %430, label %435, label %.critedge315, !prof !35

.critedge315:                                     ; preds = %427, %429
  %431 = getelementptr inbounds i8, ptr %0, i64 16
  %432 = load ptr, ptr %431, align 8, !tbaa !22
  %433 = getelementptr inbounds i8, ptr %432, i64 80
  %434 = load ptr, ptr %433, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %434, ptr noundef nonnull @.str.113, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1930) #9
  unreachable

435:                                              ; preds = %429, %422
  %436 = getelementptr inbounds i8, ptr %424, i64 304
  %437 = load i16, ptr %436, align 8, !tbaa !40
  %438 = zext i16 %437 to i64
  %439 = call zeroext i1 @is_dupfix_leaf(ptr noundef %426) #10
  br i1 %439, label %440, label %446

440:                                              ; preds = %435
  %441 = load ptr, ptr %31, align 8, !tbaa !31
  %442 = getelementptr inbounds i8, ptr %441, i64 4
  %443 = load i32, ptr %442, align 4, !tbaa !41
  %444 = zext i32 %443 to i64
  %445 = call { ptr, i64 } @page_dupfix_key(ptr noundef %426, i64 noundef %438, i64 noundef %444) #10
  br label %.sink.split

446:                                              ; preds = %435
  %447 = call ptr @page_node(ptr noundef %426, i64 noundef %438) #10
  %448 = call { ptr, i64 } @get_key(ptr noundef %447) #10
  br label %.sink.split

449:                                              ; preds = %405
  %.phi.trans.insert = getelementptr inbounds i8, ptr %0, i64 40
  %.pre348 = load ptr, ptr %.phi.trans.insert, align 8, !tbaa !45
  %.not291 = icmp eq ptr %.pre348, null
  %or.cond349 = select i1 %.not294, i1 %.not291, i1 false
  br i1 %or.cond349, label %450, label %._crit_edge347, !prof !50

450:                                              ; preds = %449
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.58, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1938) #9
  unreachable

._crit_edge347:                                   ; preds = %449
  %451 = call i64 @cursor_seek(ptr noundef %.pre348, ptr noundef %2, ptr noundef null, i32 noundef 17) #11
  %.sroa.0214.0.extract.trunc = trunc i64 %451 to i32
  %.sroa.27.0.extract.shift = lshr i64 %451, 32
  %.sroa.27.0.extract.trunc = trunc i64 %.sroa.27.0.extract.shift to i8
  %.sroa.34.0.extract.shift = lshr i64 %451, 40
  switch i32 %.sroa.0214.0.extract.trunc, label %545 [
    i32 0, label %452
    i32 -30798, label %218
  ], !prof !51

452:                                              ; preds = %._crit_edge347
  %453 = icmp eq i32 %3, 2
  br i1 %453, label %454, label %.thread338

454:                                              ; preds = %452
  %455 = trunc i64 %.sroa.27.0.extract.shift to i1
  br i1 %455, label %.thread338, label %218

456:                                              ; preds = %400
  %.not277 = icmp eq ptr %2, null
  br i1 %.not277, label %535, label %457, !prof !17

457:                                              ; preds = %456
  %458 = icmp ult i32 %3, 4
  br i1 %458, label %459, label %525

459:                                              ; preds = %457
  %460 = getelementptr inbounds i8, ptr %2, i64 8
  %461 = load i64, ptr %460, align 8, !tbaa !5
  %462 = load ptr, ptr %14, align 8, !tbaa !11
  %463 = getelementptr inbounds i8, ptr %462, i64 32
  %464 = load i64, ptr %463, align 8, !tbaa !52
  %465 = icmp ult i64 %461, %464
  br i1 %465, label %.critedge317, label %466, !prof !17

466:                                              ; preds = %459
  %467 = getelementptr inbounds i8, ptr %462, i64 40
  %468 = load i64, ptr %467, align 8, !tbaa !53
  %469 = icmp ugt i64 %461, %468
  br i1 %469, label %.critedge317, label %475, !prof !17

.critedge317:                                     ; preds = %459, %466
  br i1 %.not273, label %545, label %470, !prof !17

470:                                              ; preds = %.critedge317
  %471 = getelementptr inbounds i8, ptr %0, i64 16
  %472 = load ptr, ptr %471, align 8, !tbaa !22
  %473 = getelementptr inbounds i8, ptr %472, i64 80
  %474 = load ptr, ptr %473, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %474, ptr noundef nonnull @.str.92, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1951) #9
  unreachable

475:                                              ; preds = %466
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %9) #8
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %9, ptr noundef nonnull align 8 dereferenceable(16) %2, i64 16, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %10) #8
  %476 = load ptr, ptr %31, align 8, !tbaa !31
  %477 = load i16, ptr %476, align 4, !tbaa !32
  %478 = and i16 %477, 32
  %.not279 = icmp eq i16 %478, 0
  br i1 %.not279, label %500, label %479

479:                                              ; preds = %475
  %480 = getelementptr inbounds i8, ptr %9, i64 8
  %481 = load i64, ptr %480, align 8, !tbaa !5
  switch i64 %481, label %494 [
    i64 8, label %482
    i64 4, label %488
  ]

482:                                              ; preds = %479
  %483 = load ptr, ptr %9, align 8, !tbaa !34
  %484 = ptrtoint ptr %483 to i64
  %485 = and i64 %484, 7
  %.not282 = icmp eq i64 %485, 0
  br i1 %.not282, label %500, label %486, !prof !35

486:                                              ; preds = %482
  %487 = call ptr @bcopy_8(ptr noundef nonnull %10, ptr noundef %483)
  store ptr %487, ptr %9, align 8, !tbaa !34
  br label %500

488:                                              ; preds = %479
  %489 = load ptr, ptr %9, align 8, !tbaa !34
  %490 = ptrtoint ptr %489 to i64
  %491 = and i64 %490, 3
  %.not281 = icmp eq i64 %491, 0
  br i1 %.not281, label %500, label %492, !prof !35

492:                                              ; preds = %488
  %493 = call ptr @bcopy_4(ptr noundef nonnull %10, ptr noundef %489)
  store ptr %493, ptr %9, align 8, !tbaa !34
  br label %500

494:                                              ; preds = %479
  br i1 %.not273, label %.thread328, label %495, !prof !17

.thread328:                                       ; preds = %494
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %9) #8
  br label %545

495:                                              ; preds = %494
  %496 = getelementptr inbounds i8, ptr %0, i64 16
  %497 = load ptr, ptr %496, align 8, !tbaa !22
  %498 = getelementptr inbounds i8, ptr %497, i64 80
  %499 = load ptr, ptr %498, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %499, ptr noundef nonnull @.str.114, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1967) #9
  unreachable

500:                                              ; preds = %486, %482, %488, %492, %475
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %11) #8
  %501 = getelementptr inbounds i8, ptr %0, i64 48
  %502 = getelementptr inbounds i8, ptr %0, i64 5
  %503 = load i8, ptr %502, align 1, !tbaa !36
  %504 = sext i8 %503 to i64
  %505 = getelementptr inbounds [32 x ptr], ptr %501, i64 0, i64 %504
  %506 = load ptr, ptr %505, align 8, !tbaa !29
  %507 = call i32 @node_read(ptr noundef nonnull %0, ptr noundef %.3229, ptr noundef nonnull %11, ptr noundef %506)
  %.not283 = icmp eq i32 %507, 0
  br i1 %.not283, label %508, label %.thread331, !prof !35

508:                                              ; preds = %500
  %509 = load ptr, ptr %14, align 8, !tbaa !11
  %510 = getelementptr inbounds i8, ptr %509, i64 24
  %511 = load ptr, ptr %510, align 8, !tbaa !54
  %512 = call i32 %511(ptr noundef nonnull %9, ptr noundef nonnull %11) #8
  %.not284 = icmp eq i32 %512, 0
  br i1 %.not284, label %.thread334, label %513

513:                                              ; preds = %508
  %.not285 = icmp eq i32 %3, 3
  br i1 %.not285, label %522, label %514

514:                                              ; preds = %513
  %515 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %516 = and i8 %515, 1
  %.not286 = icmp eq i8 %516, 0
  %.not287 = icmp eq i32 %3, 2
  %or.cond318 = or i1 %.not287, %.not286
  br i1 %or.cond318, label %524, label %517, !prof !46

517:                                              ; preds = %514
  %518 = getelementptr inbounds i8, ptr %0, i64 16
  %519 = load ptr, ptr %518, align 8, !tbaa !22
  %520 = getelementptr inbounds i8, ptr %519, i64 80
  %521 = load ptr, ptr %520, align 8, !tbaa !23
  call void @mdbx_assert_fail(ptr noundef %521, ptr noundef nonnull @.str.115, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1979) #9
  unreachable

522:                                              ; preds = %513
  %523 = icmp sgt i32 %512, 0
  br i1 %523, label %.thread331, label %.thread334

.thread334:                                       ; preds = %508, %522
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %2, ptr noundef nonnull align 8 dereferenceable(16) %11, i64 16, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %11) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %9) #8
  br label %.thread338

.thread331:                                       ; preds = %500, %522
  %.sroa.0214.1.ph = phi i32 [ -30798, %522 ], [ %507, %500 ]
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %11) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %9) #8
  br label %545

524:                                              ; preds = %514
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %11) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %9) #8
  br label %218

525:                                              ; preds = %457
  %526 = getelementptr inbounds i8, ptr %0, i64 48
  %527 = getelementptr inbounds i8, ptr %0, i64 5
  %528 = load i8, ptr %527, align 1, !tbaa !36
  %529 = sext i8 %528 to i64
  %530 = getelementptr inbounds [32 x ptr], ptr %526, i64 0, i64 %529
  %531 = load ptr, ptr %530, align 8, !tbaa !29
  %532 = call i32 @node_read(ptr noundef nonnull %0, ptr noundef %.3229, ptr noundef nonnull %2, ptr noundef %531)
  %.not278 = icmp eq i32 %532, 0
  br i1 %.not278, label %535, label %545, !prof !35

.sink.split:                                      ; preds = %446, %440
  %.sink353 = phi { ptr, i64 } [ %445, %440 ], [ %448, %446 ]
  %533 = extractvalue { ptr, i64 } %.sink353, 0
  %534 = extractvalue { ptr, i64 } %.sink353, 1
  store ptr %533, ptr %2, align 8, !tbaa !29
  %.sroa.49.0..sroa_idx = getelementptr inbounds i8, ptr %2, i64 8
  store i64 %534, ptr %.sroa.49.0..sroa_idx, align 8, !tbaa !30
  br label %535

535:                                              ; preds = %.sink.split, %456, %525, %421, %417
  %536 = icmp ugt i32 %3, 15
  br i1 %536, label %537, label %.thread338

537:                                              ; preds = %535
  call void @get_key_optional(ptr noundef %.3229, ptr noundef %1)
  br label %.thread338

.thread338:                                       ; preds = %452, %454, %.thread334, %535, %537
  %.sroa.34.sroa.0.1342 = phi i64 [ 0, %535 ], [ 0, %537 ], [ 0, %.thread334 ], [ %.sroa.34.0.extract.shift, %452 ], [ %.sroa.34.0.extract.shift, %454 ]
  %.sroa.27.2341 = phi i8 [ %.sroa.27.1, %535 ], [ %.sroa.27.1, %537 ], [ %.sroa.27.1, %.thread334 ], [ %.sroa.27.0.extract.trunc, %452 ], [ %.sroa.27.0.extract.trunc, %454 ]
  %538 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !48
  %539 = icmp ugt i8 %538, 4
  br i1 %539, label %540, label %544, !prof !17

540:                                              ; preds = %.thread338
  %541 = call ptr @mdbx_dump_val(ptr noundef %1, ptr noundef nonnull %5, i64 noundef 255) #8
  %542 = getelementptr inbounds i8, ptr %5, i64 255
  %543 = call ptr @mdbx_dump_val(ptr noundef %2, ptr noundef nonnull %542, i64 noundef 255) #8
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.cursor_seek, i32 noundef 1999, ptr noundef nonnull @.str.116, ptr noundef %541, ptr noundef %543) #8
  br label %544

544:                                              ; preds = %540, %.thread338
  call void @be_filled(ptr noundef nonnull %0)
  br label %545

545:                                              ; preds = %.thread331, %.thread328, %77, %525, %.critedge317, %._crit_edge347, %417, %403, %372, %374, %321, %.loopexit, %.critedge306, %231, %97, %544, %399, %243
  %.sroa.0214.3 = phi i32 [ 0, %399 ], [ 0, %544 ], [ -30798, %243 ], [ -30798, %97 ], [ -30798, %231 ], [ -30798, %.critedge306 ], [ %263, %.loopexit ], [ %322, %321 ], [ -30796, %374 ], [ -30796, %372 ], [ %404, %403 ], [ %420, %417 ], [ %.sroa.0214.0.extract.trunc, %._crit_edge347 ], [ -30781, %.critedge317 ], [ %532, %525 ], [ -30798, %77 ], [ -30781, %.thread328 ], [ %.sroa.0214.1.ph, %.thread331 ]
  %.sroa.27.3 = phi i8 [ %.sroa.27.1, %399 ], [ %.sroa.27.2341, %544 ], [ 0, %243 ], [ 0, %97 ], [ %.sroa.27.0, %231 ], [ %.sroa.27.0, %.critedge306 ], [ 0, %.loopexit ], [ %312, %321 ], [ %.sroa.27.1, %374 ], [ %.sroa.27.1, %372 ], [ %.sroa.27.1, %403 ], [ %.sroa.27.1, %417 ], [ %.sroa.27.0.extract.trunc, %._crit_edge347 ], [ %.sroa.27.1, %.critedge317 ], [ %.sroa.27.1, %525 ], [ 0, %77 ], [ %.sroa.27.1, %.thread328 ], [ %.sroa.27.1, %.thread331 ]
  %.sroa.34.sroa.0.2 = phi i64 [ 0, %399 ], [ %.sroa.34.sroa.0.1342, %544 ], [ 0, %243 ], [ 0, %97 ], [ %.sroa.34.sroa.0.0, %231 ], [ %.sroa.34.sroa.0.0, %.critedge306 ], [ 0, %.loopexit ], [ 0, %321 ], [ 0, %374 ], [ 0, %372 ], [ 0, %403 ], [ 0, %417 ], [ %.sroa.34.0.extract.shift, %._crit_edge347 ], [ 0, %.critedge317 ], [ 0, %525 ], [ 0, %77 ], [ 0, %.thread328 ], [ 0, %.thread331 ]
  %546 = shl nuw i64 %.sroa.34.sroa.0.2, 40
  %547 = zext i8 %.sroa.27.3 to i64
  %548 = shl nuw nsw i64 %547, 32
  %549 = or disjoint i64 %546, %548
  %550 = zext i32 %.sroa.0214.3 to i64
  %551 = or disjoint i64 %549, %550
  br label %552

552:                                              ; preds = %50, %545
  %553 = phi i64 [ %551, %545 ], [ 4294936515, %50 ]
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %7) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %6) #8
  br label %554

554:                                              ; preds = %.critedge, %552
  %.sroa.0214.0.insert.insert = phi i64 [ %553, %552 ], [ 4294936515, %.critedge ]
  call void @llvm.lifetime.end.p0(i64 510, ptr nonnull %5) #8
  ret i64 %.sroa.0214.0.insert.insert
}

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

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @bcopy_4(ptr noalias noundef, ptr noalias 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 #1

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

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden { ptr, i64 } @page_dupfix_key(ptr noundef, i64 noundef, i64 noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden { ptr, i64 } @get_key(ptr noundef) local_unnamed_addr #1

declare i32 @tree_search(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #5

declare { ptr, i8 } @node_search(ptr noundef, ptr noundef) local_unnamed_addr #5

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

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !10, i64 8}
!6 = !{!"iovec", !7, i64 0, !10, i64 8}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"long", !8, i64 0}
!11 = !{!12, !7, i64 32}
!12 = !{!"MDBX_cursor", !13, i64 0, !8, i64 4, !8, i64 6, !8, i64 7, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40, !8, i64 48, !8, i64 304, !7, i64 368, !7, i64 376}
!13 = !{!"int", !8, i64 0}
!14 = !{!15, !10, i64 8}
!15 = !{!"clc2", !16, i64 0, !16, i64 24}
!16 = !{!"clc", !7, i64 0, !10, i64 8, !10, i64 16}
!17 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!18 = !{!15, !10, i64 16}
!19 = !{!20, !8, i64 25}
!20 = !{!"libmdbx_globals", !8, i64 0, !13, i64 16, !13, i64 20, !8, i64 24, !8, i64 25, !8, i64 26, !21, i64 27, !13, i64 28, !8, i64 32, !8, i64 40, !10, i64 80, !7, i64 88}
!21 = !{!"_Bool", !8, i64 0}
!22 = !{!12, !7, i64 16}
!23 = !{!24, !7, i64 80}
!24 = !{!"MDBX_txn", !13, i64 0, !13, i64 4, !10, i64 8, !10, i64 16, !7, i64 24, !7, i64 32, !25, i64 40, !10, i64 64, !10, i64 72, !7, i64 80, !7, i64 88, !7, i64 96, !7, i64 104, !7, i64 112, !7, i64 120, !27, i64 128, !7, i64 160, !8, i64 168}
!25 = !{!"geo", !26, i64 0, !26, i64 2, !13, i64 4, !13, i64 8, !8, i64 12, !8, i64 16}
!26 = !{!"short", !8, i64 0}
!27 = !{!"MDBX_canary", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24}
!28 = !{i64 0, i64 8, !29, i64 8, i64 8, !30}
!29 = !{!7, !7, i64 0}
!30 = !{!10, !10, i64 0}
!31 = !{!12, !7, i64 24}
!32 = !{!33, !26, i64 0}
!33 = !{!"tree", !26, i64 0, !26, i64 2, !13, i64 4, !13, i64 8, !13, i64 12, !13, i64 16, !13, i64 20, !10, i64 24, !10, i64 32, !10, i64 40}
!34 = !{!6, !7, i64 0}
!35 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!36 = !{!8, !8, i64 0}
!37 = !{!33, !26, i64 2}
!38 = !{!33, !13, i64 12}
!39 = !{!33, !13, i64 16}
!40 = !{!26, !26, i64 0}
!41 = !{!33, !13, i64 4}
!42 = !{!15, !7, i64 0}
!43 = distinct !{!43, !44}
!44 = !{!"llvm.loop.mustprogress"}
!45 = !{!12, !7, i64 40}
!46 = !{!"branch_weights", i32 4002001, i32 2000}
!47 = !{!"branch_weights", i32 1073205, i32 2146410443}
!48 = !{!20, !8, i64 26}
!49 = !{!13, !13, i64 0}
!50 = !{!"branch_weights", i32 2000, i32 4002001}
!51 = !{!"branch_weights", i32 1, i32 4000, i32 1}
!52 = !{!15, !10, i64 32}
!53 = !{!15, !10, i64 40}
!54 = !{!15, !7, i64 24}


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