svf-lib 1.0.1645 → 1.0.1647

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/SVF-linux/Release-build/svf/libSvfCore.a +0 -0
  2. package/SVF-linux/Release-build/svf-llvm/extapi.bc +1268 -1207
  3. package/SVF-linux/Release-build/svf-llvm/libSvfLLVM.a +0 -0
  4. package/SVF-linux/svf/include/Util/SVFUtil.h +0 -34
  5. package/SVF-linux/svf-llvm/include/SVF-LLVM/LLVMUtil.h +2 -2
  6. package/SVF-osx/Release-build/svf/libSvfCore.a +0 -0
  7. package/SVF-osx/Release-build/svf-llvm/extapi.bc +1268 -1207
  8. package/SVF-osx/Release-build/svf-llvm/libSvfLLVM.a +0 -0
  9. package/SVF-osx/svf/include/Util/SVFUtil.h +0 -34
  10. package/SVF-osx/svf-llvm/include/SVF-LLVM/LLVMUtil.h +2 -2
  11. package/package.json +1 -1
package/SVF-osx/Release-build/svf-llvm/extapi.bc CHANGED
@@ -3,33 +3,32 @@ source_filename = "/Users/runner/work/SVF/SVF/svf-llvm/lib/extapi.c"
3
3
  target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
4
4
  target triple = "x86_64-apple-macosx11.0.0"
5
5
 
6
+ %struct.dirent64 = type opaque
7
+ %struct.dirent = type opaque
8
+ %struct.jpeg_error_mgr = type opaque
9
+ %struct.mntent = type opaque
10
+ %struct.tm = type opaque
6
11
  %struct.group = type opaque
7
12
  %struct.hostent = type opaque
8
- %struct.mntent = type opaque
9
13
  %struct.protoent = type opaque
10
14
  %struct.passwd = type opaque
11
15
  %struct.servent = type opaque
12
16
  %struct.spwd = type opaque
13
- %struct.tm = type opaque
14
17
  %struct.lconv = type opaque
15
- %struct.dirent64 = type opaque
16
- %struct.dirent = type opaque
17
- %struct.jpeg_error_mgr = type opaque
18
18
 
19
19
  @.str = private unnamed_addr constant [10 x i8] c"ALLOC_RET\00", section "llvm.metadata"
20
20
  @.str.1 = private unnamed_addr constant [49 x i8] c"/Users/runner/work/SVF/SVF/svf-llvm/lib/extapi.c\00", section "llvm.metadata"
21
- @.str.2 = private unnamed_addr constant [10 x i8] c"OVERWRITE\00", section "llvm.metadata"
22
- @.str.3 = private unnamed_addr constant [7 x i8] c"STATIC\00", section "llvm.metadata"
23
- @.str.4 = private unnamed_addr constant [12 x i8] c"REALLOC_RET\00", section "llvm.metadata"
24
- @.str.5 = private unnamed_addr constant [11 x i8] c"ALLOC_ARG0\00", section "llvm.metadata"
25
- @.str.6 = private unnamed_addr constant [11 x i8] c"ALLOC_ARG1\00", section "llvm.metadata"
26
- @.str.7 = private unnamed_addr constant [11 x i8] c"ALLOC_ARG2\00", section "llvm.metadata"
27
- @.str.8 = private unnamed_addr constant [7 x i8] c"MEMCPY\00", section "llvm.metadata"
28
- @.str.9 = private unnamed_addr constant [7 x i8] c"MEMSET\00", section "llvm.metadata"
29
- @llvm.global.annotations = appending global [197 x { i8*, i8*, i8*, i32, i8* }] [{ i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @SyGetmem to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 21, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @SyGetmem to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 21, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i16** ()* @__ctype_b_loc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 28, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i16** ()* @__ctype_b_loc to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 28, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32** ()* @__ctype_tolower_loc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 35, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32** ()* @__ctype_tolower_loc to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 35, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32** ()* @__ctype_toupper_loc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 42, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32** ()* @__ctype_toupper_loc to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 42, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32* ()* @__errno_location to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 49, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32* ()* @__errno_location to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 49, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32* ()* @__h_errno_location to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 56, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32* ()* @__h_errno_location to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 56, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @__res_state to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 63, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @__res_state to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 63, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @asctime to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 70, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @asctime to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 70, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @bindtextdomain to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 77, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @bindtextdomain to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 77, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @bind_textdomain_codeset to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 84, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @bind_textdomain_codeset to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 84, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @ctermid to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 91, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @ctermid to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 91, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i32)* @dcgettext to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 98, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i32)* @dcgettext to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 98, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @dgettext to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 105, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @dgettext to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 105, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i8*, i64)* @dngettext to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 112, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i8*, i64)* @dngettext to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 112, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @fdopen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 119, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @fdopen to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 119, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.group* (i32)* @getgrgid to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 126, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.group* (i32)* @getgrgid to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 126, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.group* (i8*)* @getgrnam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 133, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.group* (i8*)* @getgrnam to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 133, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.hostent* (i8*, i32, i32)* @gethostbyaddr to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 140, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.hostent* (i8*, i32, i32)* @gethostbyaddr to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 140, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.hostent* (i8*)* @gethostbyname to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 147, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.hostent* (i8*)* @gethostbyname to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 147, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.hostent* (i8*, i32)* @gethostbyname2 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 154, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.hostent* (i8*, i32)* @gethostbyname2 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 154, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.mntent* (i8*)* @getmntent to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 161, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.mntent* (i8*)* @getmntent to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 161, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.protoent* (i8*)* @getprotobyname to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 168, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.protoent* (i8*)* @getprotobyname to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 168, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.protoent* (i32)* @getprotobynumber to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 175, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.protoent* (i32)* @getprotobynumber to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 175, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.passwd* ()* @getpwent to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 182, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.passwd* ()* @getpwent to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 182, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.passwd* (i8*)* @getpwnam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 189, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.passwd* (i8*)* @getpwnam to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 189, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.passwd* (i32)* @getpwuid to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 196, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.passwd* (i32)* @getpwuid to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 196, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.servent* (i8*, i8*)* @getservbyname to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 203, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.servent* (i8*, i8*)* @getservbyname to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 203, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.servent* (i32, i8*)* @getservbyport to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 210, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.servent* (i32, i8*)* @getservbyport to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 210, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.spwd* (i8*)* @getspnam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 217, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.spwd* (i8*)* @getspnam to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 217, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @gettext to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 224, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @gettext to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 224, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.tm* (i8*)* @gmtime to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 231, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.tm* (i8*)* @gmtime to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 231, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @gnu_get_libc_version to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 238, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @gnu_get_libc_version to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 238, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @gnutls_check_version to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 245, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @gnutls_check_version to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 245, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.lconv* ()* @localeconv to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 252, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.lconv* ()* @localeconv to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 252, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.tm* (i8*)* @localtime to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 259, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.tm* (i8*)* @localtime to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 259, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @ngettext to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 266, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @ngettext to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 266, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @pango_cairo_font_map_get_default to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 273, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @pango_cairo_font_map_get_default to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 273, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @re_comp to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 280, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @re_comp to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 280, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @setlocale to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 287, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @setlocale to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 287, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i32, i32)* @tgoto to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 294, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i32, i32)* @tgoto to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 294, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, ...)* @tparm to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 301, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, ...)* @tparm to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 301, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @zError to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 308, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @zError to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 308, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @fopen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 314, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @fopen64 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 320, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.dirent64* (i8*)* @readdir64 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 326, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @tmpvoid64 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 332, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i64)* @calloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 338, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @zmalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 344, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @gzdopen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 350, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @iconv_open to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 356, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i32)* @lalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 362, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i32)* @lalloc_clear to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 368, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i64* (i32, i8*, i32)* @nhalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 374, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @oballoc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 380, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @popen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 386, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @pthread_getspecific to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 392, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.dirent* (i8*)* @readdir to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 398, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i32)* @safe_calloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 404, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @safe_malloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 410, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i32)* @safecalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 416, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i32)* @safemalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 422, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @setmntent to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 428, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*, i32)* @shmat to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 434, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @__sysv_signal to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 440, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i32)* (i32, void (i32)*)* @signal to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 446, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @tempnam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 452, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @tmpvoid to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 458, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i64)* @xcalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 464, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @xmalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 470, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @_Znam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 476, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @_Znaj to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 482, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @_Znwj to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 488, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @__cxa_allocate_exception to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 494, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i64)* @aligned_alloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 500, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i64)* @memalign to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 506, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @valloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 512, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64, i32, i32, i32, i64)* @mmap64 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 518, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @XSetLocaleModifiers to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 524, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @__strdup to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 530, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @crypt to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 536, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @ctime to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 542, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @dlerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 548, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i32)* @dlopen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 554, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @gai_strerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 560, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @gcry_cipher_algo_name to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 566, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @svfgcry_md_algo_name_ to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 572, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @getenv to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 578, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @getlogin to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 584, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @getpass to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 590, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @gnutls_strerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 596, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @gpg_strerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 602, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i32*)* @gzerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 608, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @inet_ntoa to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 614, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @initscr to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 620, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @llvm_stacksave to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 626, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64, i32, i32, i32, i64)* @mmap to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 632, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i32, i32, i32)* @newwin to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 638, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @nl_langinfo to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 644, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @opendir to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 650, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @sbrk to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 656, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @strdup to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 662, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @strerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 668, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @strsignal to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 674, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @textdomain to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 680, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8**)* @tgetstr to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 686, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @tigetstr to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 692, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @tmpnam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 698, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @ttyname to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 704, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @malloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 710, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @getcwd to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 716, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @mem_realloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 722, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @realloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 728, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @safe_realloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 734, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64, i64)* @saferealloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 740, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @safexrealloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 746, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @strtok to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 752, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i8**)* @strtok_r to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 758, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @xrealloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 764, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @_Znwm to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 770, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i8*)* @_ZnwmRKSt9nothrow_t to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 776, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i8*)* @_ZnamRKSt9nothrow_t to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 782, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8**, i8*, ...)* @asprintf to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 788, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8**, i8*, i8*)* @vasprintf to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 794, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8**, i8*, i32)* @db_create to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 800, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*)* @gnutls_pkcs12_bag_init to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 806, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*)* @gnutls_pkcs12_init to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 812, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*)* @gnutls_x509_crt_init to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 818, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*)* @gnutls_x509_privkey_init to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 824, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8**, i64, i64)* @posix_memalign to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 830, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*, %struct.dirent***, i32 (%struct.dirent*)*, i32 (%struct.dirent**, %struct.dirent**)*)* @scandir to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 836, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*, i8*, i8***, i32*)* @XmbTextPropertyToTextList to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 842, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memcpy_p0i8_p0i8_i64 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 848, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memcpy_p0i8_p0i8_i32 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 851, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memcpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 854, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memmove to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 857, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memmove_p0i8_p0i8_i64 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 860, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memmove_p0i8_p0i8_i32 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 863, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @__memcpy_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 866, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @memmove to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 869, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i64)* @bcopy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 875, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i32, i64)* @memccpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 878, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32)* @__memmove_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 884, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8, i32, i32)* @llvm_memset to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 887, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8, i32, i32)* @llvm_memset_p0i8_i32 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 890, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8, i32, i32)* @llvm_memset_p0i8_i64 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 893, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i32, i64, i32)* @__memset_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 896, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @__strcpy_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 902, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @__strcat_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 908, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @stpcpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 914, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @strcat to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 920, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @strcpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 926, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @strncat to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 932, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @strncpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 938, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i64 (i8*, i8**, i64*, i8**, i64*)* @iconv to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 944, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @_ZNSt5arrayIPK1ALm2EE4backEv to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 950, i8* null }], section "llvm.metadata"
21
+ @.str.2 = private unnamed_addr constant [12 x i8] c"REALLOC_RET\00", section "llvm.metadata"
22
+ @.str.3 = private unnamed_addr constant [11 x i8] c"ALLOC_ARG0\00", section "llvm.metadata"
23
+ @.str.4 = private unnamed_addr constant [11 x i8] c"ALLOC_ARG1\00", section "llvm.metadata"
24
+ @.str.5 = private unnamed_addr constant [11 x i8] c"ALLOC_ARG2\00", section "llvm.metadata"
25
+ @.str.6 = private unnamed_addr constant [7 x i8] c"MEMCPY\00", section "llvm.metadata"
26
+ @.str.7 = private unnamed_addr constant [7 x i8] c"MEMSET\00", section "llvm.metadata"
27
+ @.str.8 = private unnamed_addr constant [10 x i8] c"OVERWRITE\00", section "llvm.metadata"
28
+ @llvm.global.annotations = appending global [116 x { i8*, i8*, i8*, i32, i8* }] [{ i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @malloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 18, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @fopen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 24, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @fopen64 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 30, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @fdopen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 36, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.dirent64* (i8*)* @readdir64 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 42, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @tmpvoid64 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 48, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i64)* @calloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 54, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @zmalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 60, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @gzdopen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 66, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @iconv_open to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 72, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i32)* @lalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 78, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i32)* @lalloc_clear to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 84, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i64* (i32, i8*, i32)* @nhalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 90, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @oballoc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 96, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @popen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 102, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @pthread_getspecific to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 108, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (%struct.dirent* (i8*)* @readdir to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 114, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i32)* @safe_calloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 120, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @safe_malloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 126, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i32)* @safecalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 132, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i32)* @safemalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 138, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @setmntent to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 144, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*, i32)* @shmat to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 150, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i8*)* @__sysv_signal to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 156, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i32)* (i32, void (i32)*)* @signal to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 162, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @tempnam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 168, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @tmpvoid to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 174, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i64)* @xcalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 180, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @xmalloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 186, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @_Znam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 192, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @_Znaj to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 198, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @_Znwj to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 204, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @__cxa_allocate_exception to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 210, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i64)* @aligned_alloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 216, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i64)* @memalign to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 222, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @valloc to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 228, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64, i32, i32, i32, i64)* @mmap64 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 234, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @XSetLocaleModifiers to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 240, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @__strdup to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 246, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @crypt to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 252, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @ctime to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 258, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @dlerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 264, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i32)* @dlopen to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 270, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @gai_strerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 276, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @gcry_cipher_algo_name to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 282, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @svfgcry_md_algo_name_ to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 288, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @getenv to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 294, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @getlogin to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 300, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @getpass to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 306, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @gnutls_strerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 312, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @gpg_strerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 318, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i32*)* @gzerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 324, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @inet_ntoa to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 330, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @initscr to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 336, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @llvm_stacksave to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 342, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64, i32, i32, i32, i64)* @mmap to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 348, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32, i32, i32, i32)* @newwin to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 354, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @nl_langinfo to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 360, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @opendir to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 366, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @sbrk to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 372, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @strdup to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 378, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @strerror to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 384, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @strsignal to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 390, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @textdomain to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 396, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8**)* @tgetstr to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 402, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @tigetstr to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 408, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @tmpnam to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 414, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i32)* @ttyname to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 420, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @getcwd to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 426, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @mem_realloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 432, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @realloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 438, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @safe_realloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 444, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64, i64)* @saferealloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 450, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* ()* @safexrealloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 456, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @strtok to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 462, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i8**)* @strtok_r to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 468, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i64)* @xrealloc to i8*), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 474, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @_Znwm to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 480, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i8*)* @_ZnwmRKSt9nothrow_t to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 486, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64, i8*)* @_ZnamRKSt9nothrow_t to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 492, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8**, i8*, ...)* @asprintf to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 498, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8**, i8*, i8*)* @vasprintf to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 504, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8**, i8*, i32)* @db_create to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 510, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*)* @gnutls_pkcs12_bag_init to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 516, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*)* @gnutls_pkcs12_init to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 522, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*)* @gnutls_x509_crt_init to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 528, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*)* @gnutls_x509_privkey_init to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 534, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8**, i64, i64)* @posix_memalign to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 540, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*, %struct.dirent***, i32 (%struct.dirent*)*, i32 (%struct.dirent**, %struct.dirent**)*)* @scandir to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 546, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i32 (i8*, i8*, i8***, i32*)* @XmbTextPropertyToTextList to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 552, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memcpy_p0i8_p0i8_i64 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 558, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memcpy_p0i8_p0i8_i32 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 561, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memcpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 564, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memmove to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 567, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memmove_p0i8_p0i8_i64 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 570, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @llvm_memmove_p0i8_p0i8_i32 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 573, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32, i32)* @__memcpy_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 576, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @memmove to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 579, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i64)* @bcopy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 585, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i32, i64)* @memccpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 588, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8*, i32)* @__memmove_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 594, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8, i32, i32)* @llvm_memset to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 597, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8, i32, i32)* @llvm_memset_p0i8_i32 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 600, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (i8*, i8, i32, i32)* @llvm_memset_p0i8_i64 to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 603, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i32, i64, i32)* @__memset_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 606, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @__strcpy_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 612, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @__strcat_chk to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 618, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @stpcpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 624, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @strcat to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 630, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*)* @strcpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 636, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @strncat to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 642, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*, i8*, i64)* @strncpy to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 648, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i64 (i8*, i8**, i64*, i8**, i64*)* @iconv to i8*), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 654, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i8*)* @_ZNSt5arrayIPK1ALm2EE4backEv to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 660, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @SyGetmem to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 669, i8* null }, { i8*, i8*, i8*, i32, i8* } { i8* bitcast (i8* (i64)* @SyGetmem to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i32 0, i32 0), i32 669, i8* null }], section "llvm.metadata"
30
29
 
31
30
  ; Function Attrs: noinline nounwind ssp uwtable
32
- define i8* @SyGetmem(i64 noundef %size) #0 {
31
+ define i8* @malloc(i64 noundef %size) #0 {
33
32
  entry:
34
33
  %size.addr = alloca i64, align 8
35
34
  store i64 %size, i64* %size.addr, align 8
@@ -37,2047 +36,2109 @@ entry:
37
36
  }
38
37
 
39
38
  ; Function Attrs: noinline nounwind ssp uwtable
40
- define i16** @__ctype_b_loc() #0 {
39
+ define i8* @fopen(i8* noundef %voidname, i8* noundef %mode) #0 {
41
40
  entry:
42
- ret i16** null
41
+ %voidname.addr = alloca i8*, align 8
42
+ %mode.addr = alloca i8*, align 8
43
+ store i8* %voidname, i8** %voidname.addr, align 8
44
+ store i8* %mode, i8** %mode.addr, align 8
45
+ ret i8* null
43
46
  }
44
47
 
45
48
  ; Function Attrs: noinline nounwind ssp uwtable
46
- define i32** @__ctype_tolower_loc() #0 {
49
+ define i8* @fopen64(i8* noundef %voidname, i8* noundef %mode) #0 {
47
50
  entry:
48
- ret i32** null
51
+ %voidname.addr = alloca i8*, align 8
52
+ %mode.addr = alloca i8*, align 8
53
+ store i8* %voidname, i8** %voidname.addr, align 8
54
+ store i8* %mode, i8** %mode.addr, align 8
55
+ ret i8* null
49
56
  }
50
57
 
51
58
  ; Function Attrs: noinline nounwind ssp uwtable
52
- define i32** @__ctype_toupper_loc() #0 {
59
+ define i8* @fdopen(i32 noundef %fd, i8* noundef %mode) #0 {
53
60
  entry:
54
- ret i32** null
61
+ %fd.addr = alloca i32, align 4
62
+ %mode.addr = alloca i8*, align 8
63
+ store i32 %fd, i32* %fd.addr, align 4
64
+ store i8* %mode, i8** %mode.addr, align 8
65
+ ret i8* null
55
66
  }
56
67
 
57
68
  ; Function Attrs: noinline nounwind ssp uwtable
58
- define i32* @__errno_location() #0 {
69
+ define %struct.dirent64* @readdir64(i8* noundef %dirp) #0 {
59
70
  entry:
60
- ret i32* null
71
+ %dirp.addr = alloca i8*, align 8
72
+ store i8* %dirp, i8** %dirp.addr, align 8
73
+ ret %struct.dirent64* null
61
74
  }
62
75
 
63
76
  ; Function Attrs: noinline nounwind ssp uwtable
64
- define i32* @__h_errno_location() #0 {
77
+ define i8* @tmpvoid64() #0 {
65
78
  entry:
66
- ret i32* null
79
+ ret i8* null
67
80
  }
68
81
 
69
82
  ; Function Attrs: noinline nounwind ssp uwtable
70
- define i8* @__res_state() #0 {
83
+ define i8* @calloc(i64 noundef %nitems, i64 noundef %size) #0 {
71
84
  entry:
85
+ %nitems.addr = alloca i64, align 8
86
+ %size.addr = alloca i64, align 8
87
+ store i64 %nitems, i64* %nitems.addr, align 8
88
+ store i64 %size, i64* %size.addr, align 8
72
89
  ret i8* null
73
90
  }
74
91
 
75
92
  ; Function Attrs: noinline nounwind ssp uwtable
76
- define i8* @asctime(i8* noundef %timeptr) #0 {
93
+ define i8* @zmalloc(i64 noundef %size) #0 {
77
94
  entry:
78
- %timeptr.addr = alloca i8*, align 8
79
- store i8* %timeptr, i8** %timeptr.addr, align 8
95
+ %size.addr = alloca i64, align 8
96
+ store i64 %size, i64* %size.addr, align 8
80
97
  ret i8* null
81
98
  }
82
99
 
83
100
  ; Function Attrs: noinline nounwind ssp uwtable
84
- define i8* @bindtextdomain(i8* noundef %domainname, i8* noundef %dirname) #0 {
101
+ define i8* @gzdopen(i32 noundef %fd, i8* noundef %mode) #0 {
85
102
  entry:
86
- %domainname.addr = alloca i8*, align 8
87
- %dirname.addr = alloca i8*, align 8
88
- store i8* %domainname, i8** %domainname.addr, align 8
89
- store i8* %dirname, i8** %dirname.addr, align 8
103
+ %fd.addr = alloca i32, align 4
104
+ %mode.addr = alloca i8*, align 8
105
+ store i32 %fd, i32* %fd.addr, align 4
106
+ store i8* %mode, i8** %mode.addr, align 8
90
107
  ret i8* null
91
108
  }
92
109
 
93
110
  ; Function Attrs: noinline nounwind ssp uwtable
94
- define i8* @bind_textdomain_codeset(i8* noundef %domainname, i8* noundef %codeset) #0 {
111
+ define i8* @iconv_open(i8* noundef %tocode, i8* noundef %fromcode) #0 {
95
112
  entry:
96
- %domainname.addr = alloca i8*, align 8
97
- %codeset.addr = alloca i8*, align 8
98
- store i8* %domainname, i8** %domainname.addr, align 8
99
- store i8* %codeset, i8** %codeset.addr, align 8
113
+ %tocode.addr = alloca i8*, align 8
114
+ %fromcode.addr = alloca i8*, align 8
115
+ store i8* %tocode, i8** %tocode.addr, align 8
116
+ store i8* %fromcode, i8** %fromcode.addr, align 8
100
117
  ret i8* null
101
118
  }
102
119
 
103
120
  ; Function Attrs: noinline nounwind ssp uwtable
104
- define i8* @ctermid(i8* noundef %s) #0 {
121
+ define i8* @lalloc(i64 noundef %size, i32 noundef %a) #0 {
105
122
  entry:
106
- %s.addr = alloca i8*, align 8
107
- store i8* %s, i8** %s.addr, align 8
123
+ %size.addr = alloca i64, align 8
124
+ %a.addr = alloca i32, align 4
125
+ store i64 %size, i64* %size.addr, align 8
126
+ store i32 %a, i32* %a.addr, align 4
108
127
  ret i8* null
109
128
  }
110
129
 
111
130
  ; Function Attrs: noinline nounwind ssp uwtable
112
- define i8* @dcgettext(i8* noundef %domainname, i8* noundef %msgid, i32 noundef %category) #0 {
131
+ define i8* @lalloc_clear(i64 noundef %size, i32 noundef %a) #0 {
113
132
  entry:
114
- %domainname.addr = alloca i8*, align 8
115
- %msgid.addr = alloca i8*, align 8
116
- %category.addr = alloca i32, align 4
117
- store i8* %domainname, i8** %domainname.addr, align 8
118
- store i8* %msgid, i8** %msgid.addr, align 8
119
- store i32 %category, i32* %category.addr, align 4
133
+ %size.addr = alloca i64, align 8
134
+ %a.addr = alloca i32, align 4
135
+ store i64 %size, i64* %size.addr, align 8
136
+ store i32 %a, i32* %a.addr, align 4
120
137
  ret i8* null
121
138
  }
122
139
 
123
140
  ; Function Attrs: noinline nounwind ssp uwtable
124
- define i8* @dgettext(i8* noundef %domainname, i8* noundef %msgid) #0 {
141
+ define i64* @nhalloc(i32 noundef %a, i8* noundef %b, i32 noundef %c) #0 {
125
142
  entry:
126
- %domainname.addr = alloca i8*, align 8
127
- %msgid.addr = alloca i8*, align 8
128
- store i8* %domainname, i8** %domainname.addr, align 8
129
- store i8* %msgid, i8** %msgid.addr, align 8
130
- ret i8* null
143
+ %a.addr = alloca i32, align 4
144
+ %b.addr = alloca i8*, align 8
145
+ %c.addr = alloca i32, align 4
146
+ store i32 %a, i32* %a.addr, align 4
147
+ store i8* %b, i8** %b.addr, align 8
148
+ store i32 %c, i32* %c.addr, align 4
149
+ ret i64* null
131
150
  }
132
151
 
133
152
  ; Function Attrs: noinline nounwind ssp uwtable
134
- define i8* @dngettext(i8* noundef %domainname, i8* noundef %msgid, i8* noundef %msgid_plural, i64 noundef %n) #0 {
153
+ define i8* @oballoc(i64 noundef %size) #0 {
135
154
  entry:
136
- %domainname.addr = alloca i8*, align 8
137
- %msgid.addr = alloca i8*, align 8
138
- %msgid_plural.addr = alloca i8*, align 8
139
- %n.addr = alloca i64, align 8
140
- store i8* %domainname, i8** %domainname.addr, align 8
141
- store i8* %msgid, i8** %msgid.addr, align 8
142
- store i8* %msgid_plural, i8** %msgid_plural.addr, align 8
143
- store i64 %n, i64* %n.addr, align 8
155
+ %size.addr = alloca i64, align 8
156
+ store i64 %size, i64* %size.addr, align 8
144
157
  ret i8* null
145
158
  }
146
159
 
147
160
  ; Function Attrs: noinline nounwind ssp uwtable
148
- define i8* @fdopen(i32 noundef %fd, i8* noundef %mode) #0 {
161
+ define i8* @popen(i8* noundef %command, i8* noundef %type) #0 {
149
162
  entry:
150
- %fd.addr = alloca i32, align 4
151
- %mode.addr = alloca i8*, align 8
152
- store i32 %fd, i32* %fd.addr, align 4
153
- store i8* %mode, i8** %mode.addr, align 8
163
+ %command.addr = alloca i8*, align 8
164
+ %type.addr = alloca i8*, align 8
165
+ store i8* %command, i8** %command.addr, align 8
166
+ store i8* %type, i8** %type.addr, align 8
154
167
  ret i8* null
155
168
  }
156
169
 
157
170
  ; Function Attrs: noinline nounwind ssp uwtable
158
- define %struct.group* @getgrgid(i32 noundef %gid) #0 {
171
+ define i8* @pthread_getspecific(i8* noundef %a, i8* noundef %b) #0 {
159
172
  entry:
160
- %gid.addr = alloca i32, align 4
161
- store i32 %gid, i32* %gid.addr, align 4
162
- ret %struct.group* null
173
+ %a.addr = alloca i8*, align 8
174
+ %b.addr = alloca i8*, align 8
175
+ store i8* %a, i8** %a.addr, align 8
176
+ store i8* %b, i8** %b.addr, align 8
177
+ ret i8* null
163
178
  }
164
179
 
165
180
  ; Function Attrs: noinline nounwind ssp uwtable
166
- define %struct.group* @getgrnam(i8* noundef %name) #0 {
181
+ define %struct.dirent* @readdir(i8* noundef %dirp) #0 {
167
182
  entry:
168
- %name.addr = alloca i8*, align 8
169
- store i8* %name, i8** %name.addr, align 8
170
- ret %struct.group* null
183
+ %dirp.addr = alloca i8*, align 8
184
+ store i8* %dirp, i8** %dirp.addr, align 8
185
+ ret %struct.dirent* null
171
186
  }
172
187
 
173
188
  ; Function Attrs: noinline nounwind ssp uwtable
174
- define %struct.hostent* @gethostbyaddr(i8* noundef %addr, i32 noundef %len, i32 noundef %type) #0 {
189
+ define i8* @safe_calloc(i32 noundef %nelem, i32 noundef %elsize) #0 {
175
190
  entry:
176
- %addr.addr = alloca i8*, align 8
177
- %len.addr = alloca i32, align 4
178
- %type.addr = alloca i32, align 4
179
- store i8* %addr, i8** %addr.addr, align 8
180
- store i32 %len, i32* %len.addr, align 4
181
- store i32 %type, i32* %type.addr, align 4
182
- ret %struct.hostent* null
191
+ %nelem.addr = alloca i32, align 4
192
+ %elsize.addr = alloca i32, align 4
193
+ store i32 %nelem, i32* %nelem.addr, align 4
194
+ store i32 %elsize, i32* %elsize.addr, align 4
195
+ ret i8* null
183
196
  }
184
197
 
185
198
  ; Function Attrs: noinline nounwind ssp uwtable
186
- define %struct.hostent* @gethostbyname(i8* noundef %name) #0 {
199
+ define i8* @safe_malloc(i64 noundef %size) #0 {
187
200
  entry:
188
- %name.addr = alloca i8*, align 8
189
- store i8* %name, i8** %name.addr, align 8
190
- ret %struct.hostent* null
201
+ %size.addr = alloca i64, align 8
202
+ store i64 %size, i64* %size.addr, align 8
203
+ ret i8* null
191
204
  }
192
205
 
193
206
  ; Function Attrs: noinline nounwind ssp uwtable
194
- define %struct.hostent* @gethostbyname2(i8* noundef %name, i32 noundef %af) #0 {
207
+ define i8* @safecalloc(i32 noundef %a, i32 noundef %b) #0 {
195
208
  entry:
196
- %name.addr = alloca i8*, align 8
197
- %af.addr = alloca i32, align 4
198
- store i8* %name, i8** %name.addr, align 8
199
- store i32 %af, i32* %af.addr, align 4
200
- ret %struct.hostent* null
209
+ %a.addr = alloca i32, align 4
210
+ %b.addr = alloca i32, align 4
211
+ store i32 %a, i32* %a.addr, align 4
212
+ store i32 %b, i32* %b.addr, align 4
213
+ ret i8* null
201
214
  }
202
215
 
203
216
  ; Function Attrs: noinline nounwind ssp uwtable
204
- define %struct.mntent* @getmntent(i8* noundef %stream) #0 {
217
+ define i8* @safemalloc(i32 noundef %a, i32 noundef %b) #0 {
205
218
  entry:
206
- %stream.addr = alloca i8*, align 8
207
- store i8* %stream, i8** %stream.addr, align 8
208
- ret %struct.mntent* null
219
+ %a.addr = alloca i32, align 4
220
+ %b.addr = alloca i32, align 4
221
+ store i32 %a, i32* %a.addr, align 4
222
+ store i32 %b, i32* %b.addr, align 4
223
+ ret i8* null
209
224
  }
210
225
 
211
226
  ; Function Attrs: noinline nounwind ssp uwtable
212
- define %struct.protoent* @getprotobyname(i8* noundef %name) #0 {
227
+ define i8* @setmntent(i8* noundef %voidname, i8* noundef %type) #0 {
213
228
  entry:
214
- %name.addr = alloca i8*, align 8
215
- store i8* %name, i8** %name.addr, align 8
216
- ret %struct.protoent* null
229
+ %voidname.addr = alloca i8*, align 8
230
+ %type.addr = alloca i8*, align 8
231
+ store i8* %voidname, i8** %voidname.addr, align 8
232
+ store i8* %type, i8** %type.addr, align 8
233
+ ret i8* null
217
234
  }
218
235
 
219
236
  ; Function Attrs: noinline nounwind ssp uwtable
220
- define %struct.protoent* @getprotobynumber(i32 noundef %proto) #0 {
237
+ define i8* @shmat(i32 noundef %shmid, i8* noundef %shmaddr, i32 noundef %shmflg) #0 {
221
238
  entry:
222
- %proto.addr = alloca i32, align 4
223
- store i32 %proto, i32* %proto.addr, align 4
224
- ret %struct.protoent* null
239
+ %shmid.addr = alloca i32, align 4
240
+ %shmaddr.addr = alloca i8*, align 8
241
+ %shmflg.addr = alloca i32, align 4
242
+ store i32 %shmid, i32* %shmid.addr, align 4
243
+ store i8* %shmaddr, i8** %shmaddr.addr, align 8
244
+ store i32 %shmflg, i32* %shmflg.addr, align 4
245
+ ret i8* null
225
246
  }
226
247
 
227
248
  ; Function Attrs: noinline nounwind ssp uwtable
228
- define %struct.passwd* @getpwent() #0 {
249
+ define i8* @__sysv_signal(i32 noundef %a, i8* noundef %b) #0 {
229
250
  entry:
230
- ret %struct.passwd* null
251
+ %a.addr = alloca i32, align 4
252
+ %b.addr = alloca i8*, align 8
253
+ store i32 %a, i32* %a.addr, align 4
254
+ store i8* %b, i8** %b.addr, align 8
255
+ ret i8* null
231
256
  }
232
257
 
233
258
  ; Function Attrs: noinline nounwind ssp uwtable
234
- define %struct.passwd* @getpwnam(i8* noundef %name) #0 {
259
+ define void (i32)* @signal(i32 noundef %sig, void (i32)* noundef %func) #0 {
235
260
  entry:
236
- %name.addr = alloca i8*, align 8
237
- store i8* %name, i8** %name.addr, align 8
238
- ret %struct.passwd* null
261
+ %sig.addr = alloca i32, align 4
262
+ %func.addr = alloca void (i32)*, align 8
263
+ store i32 %sig, i32* %sig.addr, align 4
264
+ store void (i32)* %func, void (i32)** %func.addr, align 8
265
+ ret void (i32)* null
239
266
  }
240
267
 
241
268
  ; Function Attrs: noinline nounwind ssp uwtable
242
- define %struct.passwd* @getpwuid(i32 noundef %uid) #0 {
269
+ define i8* @tempnam(i8* noundef %dir, i8* noundef %pfx) #0 {
243
270
  entry:
244
- %uid.addr = alloca i32, align 4
245
- store i32 %uid, i32* %uid.addr, align 4
246
- ret %struct.passwd* null
271
+ %dir.addr = alloca i8*, align 8
272
+ %pfx.addr = alloca i8*, align 8
273
+ store i8* %dir, i8** %dir.addr, align 8
274
+ store i8* %pfx, i8** %pfx.addr, align 8
275
+ ret i8* null
247
276
  }
248
277
 
249
278
  ; Function Attrs: noinline nounwind ssp uwtable
250
- define %struct.servent* @getservbyname(i8* noundef %name, i8* noundef %proto) #0 {
279
+ define i8* @tmpvoid() #0 {
251
280
  entry:
252
- %name.addr = alloca i8*, align 8
253
- %proto.addr = alloca i8*, align 8
254
- store i8* %name, i8** %name.addr, align 8
255
- store i8* %proto, i8** %proto.addr, align 8
256
- ret %struct.servent* null
281
+ ret i8* null
257
282
  }
258
283
 
259
284
  ; Function Attrs: noinline nounwind ssp uwtable
260
- define %struct.servent* @getservbyport(i32 noundef %port, i8* noundef %proto) #0 {
285
+ define i8* @xcalloc(i64 noundef %size1, i64 noundef %size2) #0 {
261
286
  entry:
262
- %port.addr = alloca i32, align 4
263
- %proto.addr = alloca i8*, align 8
264
- store i32 %port, i32* %port.addr, align 4
265
- store i8* %proto, i8** %proto.addr, align 8
266
- ret %struct.servent* null
287
+ %size1.addr = alloca i64, align 8
288
+ %size2.addr = alloca i64, align 8
289
+ store i64 %size1, i64* %size1.addr, align 8
290
+ store i64 %size2, i64* %size2.addr, align 8
291
+ ret i8* null
267
292
  }
268
293
 
269
294
  ; Function Attrs: noinline nounwind ssp uwtable
270
- define %struct.spwd* @getspnam(i8* noundef %name) #0 {
295
+ define i8* @xmalloc(i64 noundef %size) #0 {
271
296
  entry:
272
- %name.addr = alloca i8*, align 8
273
- store i8* %name, i8** %name.addr, align 8
274
- ret %struct.spwd* null
297
+ %size.addr = alloca i64, align 8
298
+ store i64 %size, i64* %size.addr, align 8
299
+ ret i8* null
275
300
  }
276
301
 
277
302
  ; Function Attrs: noinline nounwind ssp uwtable
278
- define i8* @gettext(i8* noundef %msgid) #0 {
303
+ define i8* @_Znam(i64 noundef %size) #0 {
279
304
  entry:
280
- %msgid.addr = alloca i8*, align 8
281
- store i8* %msgid, i8** %msgid.addr, align 8
305
+ %size.addr = alloca i64, align 8
306
+ store i64 %size, i64* %size.addr, align 8
282
307
  ret i8* null
283
308
  }
284
309
 
285
310
  ; Function Attrs: noinline nounwind ssp uwtable
286
- define %struct.tm* @gmtime(i8* noundef %timer) #0 {
311
+ define i8* @_Znaj(i64 noundef %size) #0 {
287
312
  entry:
288
- %timer.addr = alloca i8*, align 8
289
- store i8* %timer, i8** %timer.addr, align 8
290
- ret %struct.tm* null
313
+ %size.addr = alloca i64, align 8
314
+ store i64 %size, i64* %size.addr, align 8
315
+ ret i8* null
291
316
  }
292
317
 
293
318
  ; Function Attrs: noinline nounwind ssp uwtable
294
- define i8* @gnu_get_libc_version() #0 {
319
+ define i8* @_Znwj(i64 noundef %size) #0 {
295
320
  entry:
321
+ %size.addr = alloca i64, align 8
322
+ store i64 %size, i64* %size.addr, align 8
296
323
  ret i8* null
297
324
  }
298
325
 
299
326
  ; Function Attrs: noinline nounwind ssp uwtable
300
- define i8* @gnutls_check_version(i8* noundef %req_version) #0 {
327
+ define i8* @__cxa_allocate_exception(i64 noundef %size) #0 {
301
328
  entry:
302
- %req_version.addr = alloca i8*, align 8
303
- store i8* %req_version, i8** %req_version.addr, align 8
329
+ %size.addr = alloca i64, align 8
330
+ store i64 %size, i64* %size.addr, align 8
304
331
  ret i8* null
305
332
  }
306
333
 
307
334
  ; Function Attrs: noinline nounwind ssp uwtable
308
- define %struct.lconv* @localeconv() #0 {
335
+ define i8* @aligned_alloc(i64 noundef %size1, i64 noundef %size2) #0 {
309
336
  entry:
310
- ret %struct.lconv* null
337
+ %size1.addr = alloca i64, align 8
338
+ %size2.addr = alloca i64, align 8
339
+ store i64 %size1, i64* %size1.addr, align 8
340
+ store i64 %size2, i64* %size2.addr, align 8
341
+ ret i8* null
311
342
  }
312
343
 
313
344
  ; Function Attrs: noinline nounwind ssp uwtable
314
- define %struct.tm* @localtime(i8* noundef %timer) #0 {
345
+ define i8* @memalign(i64 noundef %size1, i64 noundef %size2) #0 {
315
346
  entry:
316
- %timer.addr = alloca i8*, align 8
317
- store i8* %timer, i8** %timer.addr, align 8
318
- ret %struct.tm* null
347
+ %size1.addr = alloca i64, align 8
348
+ %size2.addr = alloca i64, align 8
349
+ store i64 %size1, i64* %size1.addr, align 8
350
+ store i64 %size2, i64* %size2.addr, align 8
351
+ ret i8* null
319
352
  }
320
353
 
321
354
  ; Function Attrs: noinline nounwind ssp uwtable
322
- define i8* @ngettext(i8* noundef %msgid, i8* noundef %msgid_plural, i64 noundef %n) #0 {
355
+ define i8* @valloc(i64 noundef %size) #0 {
323
356
  entry:
324
- %msgid.addr = alloca i8*, align 8
325
- %msgid_plural.addr = alloca i8*, align 8
326
- %n.addr = alloca i64, align 8
327
- store i8* %msgid, i8** %msgid.addr, align 8
328
- store i8* %msgid_plural, i8** %msgid_plural.addr, align 8
329
- store i64 %n, i64* %n.addr, align 8
357
+ %size.addr = alloca i64, align 8
358
+ store i64 %size, i64* %size.addr, align 8
330
359
  ret i8* null
331
360
  }
332
361
 
333
362
  ; Function Attrs: noinline nounwind ssp uwtable
334
- define i8* @pango_cairo_font_map_get_default() #0 {
363
+ define i8* @mmap64(i8* noundef %addr, i64 noundef %len, i32 noundef %prot, i32 noundef %flags, i32 noundef %fildes, i64 noundef %off) #0 {
335
364
  entry:
365
+ %addr.addr = alloca i8*, align 8
366
+ %len.addr = alloca i64, align 8
367
+ %prot.addr = alloca i32, align 4
368
+ %flags.addr = alloca i32, align 4
369
+ %fildes.addr = alloca i32, align 4
370
+ %off.addr = alloca i64, align 8
371
+ store i8* %addr, i8** %addr.addr, align 8
372
+ store i64 %len, i64* %len.addr, align 8
373
+ store i32 %prot, i32* %prot.addr, align 4
374
+ store i32 %flags, i32* %flags.addr, align 4
375
+ store i32 %fildes, i32* %fildes.addr, align 4
376
+ store i64 %off, i64* %off.addr, align 8
336
377
  ret i8* null
337
378
  }
338
379
 
339
380
  ; Function Attrs: noinline nounwind ssp uwtable
340
- define i8* @re_comp(i8* noundef %regex) #0 {
381
+ define i8* @XSetLocaleModifiers(i8* noundef %a) #0 {
341
382
  entry:
342
- %regex.addr = alloca i8*, align 8
343
- store i8* %regex, i8** %regex.addr, align 8
383
+ %a.addr = alloca i8*, align 8
384
+ store i8* %a, i8** %a.addr, align 8
344
385
  ret i8* null
345
386
  }
346
387
 
347
388
  ; Function Attrs: noinline nounwind ssp uwtable
348
- define i8* @setlocale(i32 noundef %category, i8* noundef %locale) #0 {
389
+ define i8* @__strdup(i8* noundef %string) #0 {
349
390
  entry:
350
- %category.addr = alloca i32, align 4
351
- %locale.addr = alloca i8*, align 8
352
- store i32 %category, i32* %category.addr, align 4
353
- store i8* %locale, i8** %locale.addr, align 8
391
+ %string.addr = alloca i8*, align 8
392
+ store i8* %string, i8** %string.addr, align 8
354
393
  ret i8* null
355
394
  }
356
395
 
357
396
  ; Function Attrs: noinline nounwind ssp uwtable
358
- define i8* @tgoto(i8* noundef %cap, i32 noundef %col, i32 noundef %row) #0 {
397
+ define i8* @crypt(i8* noundef %key, i8* noundef %salt) #0 {
359
398
  entry:
360
- %cap.addr = alloca i8*, align 8
361
- %col.addr = alloca i32, align 4
362
- %row.addr = alloca i32, align 4
363
- store i8* %cap, i8** %cap.addr, align 8
364
- store i32 %col, i32* %col.addr, align 4
365
- store i32 %row, i32* %row.addr, align 4
399
+ %key.addr = alloca i8*, align 8
400
+ %salt.addr = alloca i8*, align 8
401
+ store i8* %key, i8** %key.addr, align 8
402
+ store i8* %salt, i8** %salt.addr, align 8
366
403
  ret i8* null
367
404
  }
368
405
 
369
406
  ; Function Attrs: noinline nounwind ssp uwtable
370
- define i8* @tparm(i8* noundef %str, ...) #0 {
407
+ define i8* @ctime(i8* noundef %timer) #0 {
371
408
  entry:
372
- %str.addr = alloca i8*, align 8
373
- store i8* %str, i8** %str.addr, align 8
409
+ %timer.addr = alloca i8*, align 8
410
+ store i8* %timer, i8** %timer.addr, align 8
374
411
  ret i8* null
375
412
  }
376
413
 
377
414
  ; Function Attrs: noinline nounwind ssp uwtable
378
- define i8* @zError(i32 noundef %a) #0 {
415
+ define i8* @dlerror() #0 {
379
416
  entry:
380
- %a.addr = alloca i32, align 4
381
- store i32 %a, i32* %a.addr, align 4
382
417
  ret i8* null
383
418
  }
384
419
 
385
420
  ; Function Attrs: noinline nounwind ssp uwtable
386
- define i8* @fopen(i8* noundef %voidname, i8* noundef %mode) #0 {
421
+ define i8* @dlopen(i8* noundef %voidname, i32 noundef %flags) #0 {
387
422
  entry:
388
423
  %voidname.addr = alloca i8*, align 8
389
- %mode.addr = alloca i8*, align 8
424
+ %flags.addr = alloca i32, align 4
390
425
  store i8* %voidname, i8** %voidname.addr, align 8
391
- store i8* %mode, i8** %mode.addr, align 8
426
+ store i32 %flags, i32* %flags.addr, align 4
392
427
  ret i8* null
393
428
  }
394
429
 
395
430
  ; Function Attrs: noinline nounwind ssp uwtable
396
- define i8* @fopen64(i8* noundef %voidname, i8* noundef %mode) #0 {
431
+ define i8* @gai_strerror(i32 noundef %errcode) #0 {
397
432
  entry:
398
- %voidname.addr = alloca i8*, align 8
399
- %mode.addr = alloca i8*, align 8
400
- store i8* %voidname, i8** %voidname.addr, align 8
401
- store i8* %mode, i8** %mode.addr, align 8
433
+ %errcode.addr = alloca i32, align 4
434
+ store i32 %errcode, i32* %errcode.addr, align 4
402
435
  ret i8* null
403
436
  }
404
437
 
405
438
  ; Function Attrs: noinline nounwind ssp uwtable
406
- define %struct.dirent64* @readdir64(i8* noundef %dirp) #0 {
439
+ define i8* @gcry_cipher_algo_name(i32 noundef %errcode) #0 {
407
440
  entry:
408
- %dirp.addr = alloca i8*, align 8
409
- store i8* %dirp, i8** %dirp.addr, align 8
410
- ret %struct.dirent64* null
441
+ %errcode.addr = alloca i32, align 4
442
+ store i32 %errcode, i32* %errcode.addr, align 4
443
+ ret i8* null
411
444
  }
412
445
 
413
446
  ; Function Attrs: noinline nounwind ssp uwtable
414
- define i8* @tmpvoid64() #0 {
447
+ define i8* @svfgcry_md_algo_name_(i32 noundef %errcode) #0 {
415
448
  entry:
449
+ %errcode.addr = alloca i32, align 4
450
+ store i32 %errcode, i32* %errcode.addr, align 4
416
451
  ret i8* null
417
452
  }
418
453
 
419
454
  ; Function Attrs: noinline nounwind ssp uwtable
420
- define i8* @calloc(i64 noundef %nitems, i64 noundef %size) #0 {
455
+ define i8* @getenv(i8* noundef %name) #0 {
421
456
  entry:
422
- %nitems.addr = alloca i64, align 8
423
- %size.addr = alloca i64, align 8
424
- store i64 %nitems, i64* %nitems.addr, align 8
425
- store i64 %size, i64* %size.addr, align 8
457
+ %name.addr = alloca i8*, align 8
458
+ store i8* %name, i8** %name.addr, align 8
426
459
  ret i8* null
427
460
  }
428
461
 
429
462
  ; Function Attrs: noinline nounwind ssp uwtable
430
- define i8* @zmalloc(i64 noundef %size) #0 {
463
+ define i8* @getlogin() #0 {
431
464
  entry:
432
- %size.addr = alloca i64, align 8
433
- store i64 %size, i64* %size.addr, align 8
434
465
  ret i8* null
435
466
  }
436
467
 
437
468
  ; Function Attrs: noinline nounwind ssp uwtable
438
- define i8* @gzdopen(i32 noundef %fd, i8* noundef %mode) #0 {
469
+ define i8* @getpass(i8* noundef %prompt) #0 {
439
470
  entry:
440
- %fd.addr = alloca i32, align 4
441
- %mode.addr = alloca i8*, align 8
442
- store i32 %fd, i32* %fd.addr, align 4
443
- store i8* %mode, i8** %mode.addr, align 8
471
+ %prompt.addr = alloca i8*, align 8
472
+ store i8* %prompt, i8** %prompt.addr, align 8
444
473
  ret i8* null
445
474
  }
446
475
 
447
476
  ; Function Attrs: noinline nounwind ssp uwtable
448
- define i8* @iconv_open(i8* noundef %tocode, i8* noundef %fromcode) #0 {
477
+ define i8* @gnutls_strerror(i32 noundef %error) #0 {
449
478
  entry:
450
- %tocode.addr = alloca i8*, align 8
451
- %fromcode.addr = alloca i8*, align 8
452
- store i8* %tocode, i8** %tocode.addr, align 8
453
- store i8* %fromcode, i8** %fromcode.addr, align 8
479
+ %error.addr = alloca i32, align 4
480
+ store i32 %error, i32* %error.addr, align 4
454
481
  ret i8* null
455
482
  }
456
483
 
457
484
  ; Function Attrs: noinline nounwind ssp uwtable
458
- define i8* @lalloc(i64 noundef %size, i32 noundef %a) #0 {
485
+ define i8* @gpg_strerror(i32 noundef %a) #0 {
459
486
  entry:
460
- %size.addr = alloca i64, align 8
461
487
  %a.addr = alloca i32, align 4
462
- store i64 %size, i64* %size.addr, align 8
463
488
  store i32 %a, i32* %a.addr, align 4
464
489
  ret i8* null
465
490
  }
466
491
 
467
492
  ; Function Attrs: noinline nounwind ssp uwtable
468
- define i8* @lalloc_clear(i64 noundef %size, i32 noundef %a) #0 {
493
+ define i8* @gzerror(i8* noundef %file, i32* noundef %errnum) #0 {
469
494
  entry:
470
- %size.addr = alloca i64, align 8
471
- %a.addr = alloca i32, align 4
472
- store i64 %size, i64* %size.addr, align 8
473
- store i32 %a, i32* %a.addr, align 4
495
+ %file.addr = alloca i8*, align 8
496
+ %errnum.addr = alloca i32*, align 8
497
+ store i8* %file, i8** %file.addr, align 8
498
+ store i32* %errnum, i32** %errnum.addr, align 8
474
499
  ret i8* null
475
500
  }
476
501
 
477
502
  ; Function Attrs: noinline nounwind ssp uwtable
478
- define i64* @nhalloc(i32 noundef %a, i8* noundef %b, i32 noundef %c) #0 {
503
+ define i8* @inet_ntoa(i32 noundef %in) #0 {
479
504
  entry:
480
- %a.addr = alloca i32, align 4
481
- %b.addr = alloca i8*, align 8
482
- %c.addr = alloca i32, align 4
483
- store i32 %a, i32* %a.addr, align 4
484
- store i8* %b, i8** %b.addr, align 8
485
- store i32 %c, i32* %c.addr, align 4
486
- ret i64* null
505
+ %in.addr = alloca i32, align 4
506
+ store i32 %in, i32* %in.addr, align 4
507
+ ret i8* null
487
508
  }
488
509
 
489
510
  ; Function Attrs: noinline nounwind ssp uwtable
490
- define i8* @oballoc(i64 noundef %size) #0 {
511
+ define i8* @initscr() #0 {
491
512
  entry:
492
- %size.addr = alloca i64, align 8
493
- store i64 %size, i64* %size.addr, align 8
494
513
  ret i8* null
495
514
  }
496
515
 
497
516
  ; Function Attrs: noinline nounwind ssp uwtable
498
- define i8* @popen(i8* noundef %command, i8* noundef %type) #0 {
517
+ define i8* @llvm_stacksave() #0 {
499
518
  entry:
500
- %command.addr = alloca i8*, align 8
501
- %type.addr = alloca i8*, align 8
502
- store i8* %command, i8** %command.addr, align 8
503
- store i8* %type, i8** %type.addr, align 8
504
519
  ret i8* null
505
520
  }
506
521
 
507
522
  ; Function Attrs: noinline nounwind ssp uwtable
508
- define i8* @pthread_getspecific(i8* noundef %a, i8* noundef %b) #0 {
523
+ define i8* @mmap(i8* noundef %addr, i64 noundef %len, i32 noundef %prot, i32 noundef %flags, i32 noundef %fildes, i64 noundef %off) #0 {
509
524
  entry:
510
- %a.addr = alloca i8*, align 8
511
- %b.addr = alloca i8*, align 8
512
- store i8* %a, i8** %a.addr, align 8
513
- store i8* %b, i8** %b.addr, align 8
525
+ %addr.addr = alloca i8*, align 8
526
+ %len.addr = alloca i64, align 8
527
+ %prot.addr = alloca i32, align 4
528
+ %flags.addr = alloca i32, align 4
529
+ %fildes.addr = alloca i32, align 4
530
+ %off.addr = alloca i64, align 8
531
+ store i8* %addr, i8** %addr.addr, align 8
532
+ store i64 %len, i64* %len.addr, align 8
533
+ store i32 %prot, i32* %prot.addr, align 4
534
+ store i32 %flags, i32* %flags.addr, align 4
535
+ store i32 %fildes, i32* %fildes.addr, align 4
536
+ store i64 %off, i64* %off.addr, align 8
514
537
  ret i8* null
515
538
  }
516
539
 
517
540
  ; Function Attrs: noinline nounwind ssp uwtable
518
- define %struct.dirent* @readdir(i8* noundef %dirp) #0 {
541
+ define i8* @newwin(i32 noundef %nlines, i32 noundef %ncols, i32 noundef %begin_y, i32 noundef %begin_x) #0 {
519
542
  entry:
520
- %dirp.addr = alloca i8*, align 8
521
- store i8* %dirp, i8** %dirp.addr, align 8
522
- ret %struct.dirent* null
543
+ %nlines.addr = alloca i32, align 4
544
+ %ncols.addr = alloca i32, align 4
545
+ %begin_y.addr = alloca i32, align 4
546
+ %begin_x.addr = alloca i32, align 4
547
+ store i32 %nlines, i32* %nlines.addr, align 4
548
+ store i32 %ncols, i32* %ncols.addr, align 4
549
+ store i32 %begin_y, i32* %begin_y.addr, align 4
550
+ store i32 %begin_x, i32* %begin_x.addr, align 4
551
+ ret i8* null
523
552
  }
524
553
 
525
554
  ; Function Attrs: noinline nounwind ssp uwtable
526
- define i8* @safe_calloc(i32 noundef %nelem, i32 noundef %elsize) #0 {
555
+ define i8* @nl_langinfo(i32 noundef %item) #0 {
527
556
  entry:
528
- %nelem.addr = alloca i32, align 4
529
- %elsize.addr = alloca i32, align 4
530
- store i32 %nelem, i32* %nelem.addr, align 4
531
- store i32 %elsize, i32* %elsize.addr, align 4
557
+ %item.addr = alloca i32, align 4
558
+ store i32 %item, i32* %item.addr, align 4
532
559
  ret i8* null
533
560
  }
534
561
 
535
562
  ; Function Attrs: noinline nounwind ssp uwtable
536
- define i8* @safe_malloc(i64 noundef %size) #0 {
563
+ define i8* @opendir(i8* noundef %name) #0 {
537
564
  entry:
538
- %size.addr = alloca i64, align 8
539
- store i64 %size, i64* %size.addr, align 8
565
+ %name.addr = alloca i8*, align 8
566
+ store i8* %name, i8** %name.addr, align 8
540
567
  ret i8* null
541
568
  }
542
569
 
543
570
  ; Function Attrs: noinline nounwind ssp uwtable
544
- define i8* @safecalloc(i32 noundef %a, i32 noundef %b) #0 {
571
+ define i8* @sbrk(i64 noundef %increment) #0 {
545
572
  entry:
546
- %a.addr = alloca i32, align 4
547
- %b.addr = alloca i32, align 4
548
- store i32 %a, i32* %a.addr, align 4
549
- store i32 %b, i32* %b.addr, align 4
573
+ %increment.addr = alloca i64, align 8
574
+ store i64 %increment, i64* %increment.addr, align 8
550
575
  ret i8* null
551
576
  }
552
577
 
553
578
  ; Function Attrs: noinline nounwind ssp uwtable
554
- define i8* @safemalloc(i32 noundef %a, i32 noundef %b) #0 {
579
+ define i8* @strdup(i8* noundef %s) #0 {
555
580
  entry:
556
- %a.addr = alloca i32, align 4
557
- %b.addr = alloca i32, align 4
558
- store i32 %a, i32* %a.addr, align 4
559
- store i32 %b, i32* %b.addr, align 4
581
+ %s.addr = alloca i8*, align 8
582
+ store i8* %s, i8** %s.addr, align 8
560
583
  ret i8* null
561
584
  }
562
585
 
563
586
  ; Function Attrs: noinline nounwind ssp uwtable
564
- define i8* @setmntent(i8* noundef %voidname, i8* noundef %type) #0 {
587
+ define i8* @strerror(i32 noundef %errnum) #0 {
565
588
  entry:
566
- %voidname.addr = alloca i8*, align 8
567
- %type.addr = alloca i8*, align 8
568
- store i8* %voidname, i8** %voidname.addr, align 8
569
- store i8* %type, i8** %type.addr, align 8
589
+ %errnum.addr = alloca i32, align 4
590
+ store i32 %errnum, i32* %errnum.addr, align 4
570
591
  ret i8* null
571
592
  }
572
593
 
573
594
  ; Function Attrs: noinline nounwind ssp uwtable
574
- define i8* @shmat(i32 noundef %shmid, i8* noundef %shmaddr, i32 noundef %shmflg) #0 {
595
+ define i8* @strsignal(i32 noundef %errnum) #0 {
575
596
  entry:
576
- %shmid.addr = alloca i32, align 4
577
- %shmaddr.addr = alloca i8*, align 8
578
- %shmflg.addr = alloca i32, align 4
579
- store i32 %shmid, i32* %shmid.addr, align 4
580
- store i8* %shmaddr, i8** %shmaddr.addr, align 8
581
- store i32 %shmflg, i32* %shmflg.addr, align 4
597
+ %errnum.addr = alloca i32, align 4
598
+ store i32 %errnum, i32* %errnum.addr, align 4
582
599
  ret i8* null
583
600
  }
584
601
 
585
602
  ; Function Attrs: noinline nounwind ssp uwtable
586
- define i8* @__sysv_signal(i32 noundef %a, i8* noundef %b) #0 {
603
+ define i8* @textdomain(i8* noundef %domainname) #0 {
587
604
  entry:
588
- %a.addr = alloca i32, align 4
589
- %b.addr = alloca i8*, align 8
590
- store i32 %a, i32* %a.addr, align 4
591
- store i8* %b, i8** %b.addr, align 8
605
+ %domainname.addr = alloca i8*, align 8
606
+ store i8* %domainname, i8** %domainname.addr, align 8
592
607
  ret i8* null
593
608
  }
594
609
 
595
610
  ; Function Attrs: noinline nounwind ssp uwtable
596
- define void (i32)* @signal(i32 noundef %sig, void (i32)* noundef %func) #0 {
611
+ define i8* @tgetstr(i8* noundef %id, i8** noundef %area) #0 {
597
612
  entry:
598
- %sig.addr = alloca i32, align 4
599
- %func.addr = alloca void (i32)*, align 8
600
- store i32 %sig, i32* %sig.addr, align 4
601
- store void (i32)* %func, void (i32)** %func.addr, align 8
602
- ret void (i32)* null
613
+ %id.addr = alloca i8*, align 8
614
+ %area.addr = alloca i8**, align 8
615
+ store i8* %id, i8** %id.addr, align 8
616
+ store i8** %area, i8*** %area.addr, align 8
617
+ ret i8* null
603
618
  }
604
619
 
605
620
  ; Function Attrs: noinline nounwind ssp uwtable
606
- define i8* @tempnam(i8* noundef %dir, i8* noundef %pfx) #0 {
621
+ define i8* @tigetstr(i8* noundef %capname) #0 {
607
622
  entry:
608
- %dir.addr = alloca i8*, align 8
609
- %pfx.addr = alloca i8*, align 8
610
- store i8* %dir, i8** %dir.addr, align 8
611
- store i8* %pfx, i8** %pfx.addr, align 8
623
+ %capname.addr = alloca i8*, align 8
624
+ store i8* %capname, i8** %capname.addr, align 8
612
625
  ret i8* null
613
626
  }
614
627
 
615
628
  ; Function Attrs: noinline nounwind ssp uwtable
616
- define i8* @tmpvoid() #0 {
629
+ define i8* @tmpnam(i8* noundef %s) #0 {
617
630
  entry:
631
+ %s.addr = alloca i8*, align 8
632
+ store i8* %s, i8** %s.addr, align 8
618
633
  ret i8* null
619
634
  }
620
635
 
621
636
  ; Function Attrs: noinline nounwind ssp uwtable
622
- define i8* @xcalloc(i64 noundef %size1, i64 noundef %size2) #0 {
637
+ define i8* @ttyname(i32 noundef %fd) #0 {
623
638
  entry:
624
- %size1.addr = alloca i64, align 8
625
- %size2.addr = alloca i64, align 8
626
- store i64 %size1, i64* %size1.addr, align 8
627
- store i64 %size2, i64* %size2.addr, align 8
639
+ %fd.addr = alloca i32, align 4
640
+ store i32 %fd, i32* %fd.addr, align 4
628
641
  ret i8* null
629
642
  }
630
643
 
631
644
  ; Function Attrs: noinline nounwind ssp uwtable
632
- define i8* @xmalloc(i64 noundef %size) #0 {
645
+ define i8* @getcwd(i8* noundef %buf, i64 noundef %size) #0 {
633
646
  entry:
647
+ %buf.addr = alloca i8*, align 8
634
648
  %size.addr = alloca i64, align 8
649
+ store i8* %buf, i8** %buf.addr, align 8
635
650
  store i64 %size, i64* %size.addr, align 8
636
651
  ret i8* null
637
652
  }
638
653
 
639
654
  ; Function Attrs: noinline nounwind ssp uwtable
640
- define i8* @_Znam(i64 noundef %size) #0 {
655
+ define i8* @mem_realloc(i8* noundef %ptr, i64 noundef %size) #0 {
641
656
  entry:
657
+ %ptr.addr = alloca i8*, align 8
642
658
  %size.addr = alloca i64, align 8
659
+ store i8* %ptr, i8** %ptr.addr, align 8
643
660
  store i64 %size, i64* %size.addr, align 8
644
661
  ret i8* null
645
662
  }
646
663
 
647
664
  ; Function Attrs: noinline nounwind ssp uwtable
648
- define i8* @_Znaj(i64 noundef %size) #0 {
665
+ define i8* @realloc(i8* noundef %ptr, i64 noundef %size) #0 {
649
666
  entry:
667
+ %ptr.addr = alloca i8*, align 8
650
668
  %size.addr = alloca i64, align 8
669
+ store i8* %ptr, i8** %ptr.addr, align 8
651
670
  store i64 %size, i64* %size.addr, align 8
652
671
  ret i8* null
653
672
  }
654
673
 
655
674
  ; Function Attrs: noinline nounwind ssp uwtable
656
- define i8* @_Znwj(i64 noundef %size) #0 {
675
+ define i8* @safe_realloc(i8* noundef %p, i64 noundef %n) #0 {
657
676
  entry:
658
- %size.addr = alloca i64, align 8
659
- store i64 %size, i64* %size.addr, align 8
677
+ %p.addr = alloca i8*, align 8
678
+ %n.addr = alloca i64, align 8
679
+ store i8* %p, i8** %p.addr, align 8
680
+ store i64 %n, i64* %n.addr, align 8
660
681
  ret i8* null
661
682
  }
662
683
 
663
684
  ; Function Attrs: noinline nounwind ssp uwtable
664
- define i8* @__cxa_allocate_exception(i64 noundef %size) #0 {
685
+ define i8* @saferealloc(i8* noundef %p, i64 noundef %n1, i64 noundef %n2) #0 {
665
686
  entry:
666
- %size.addr = alloca i64, align 8
667
- store i64 %size, i64* %size.addr, align 8
687
+ %p.addr = alloca i8*, align 8
688
+ %n1.addr = alloca i64, align 8
689
+ %n2.addr = alloca i64, align 8
690
+ store i8* %p, i8** %p.addr, align 8
691
+ store i64 %n1, i64* %n1.addr, align 8
692
+ store i64 %n2, i64* %n2.addr, align 8
668
693
  ret i8* null
669
694
  }
670
695
 
671
696
  ; Function Attrs: noinline nounwind ssp uwtable
672
- define i8* @aligned_alloc(i64 noundef %size1, i64 noundef %size2) #0 {
697
+ define i8* @safexrealloc() #0 {
673
698
  entry:
674
- %size1.addr = alloca i64, align 8
675
- %size2.addr = alloca i64, align 8
676
- store i64 %size1, i64* %size1.addr, align 8
677
- store i64 %size2, i64* %size2.addr, align 8
678
699
  ret i8* null
679
700
  }
680
701
 
681
702
  ; Function Attrs: noinline nounwind ssp uwtable
682
- define i8* @memalign(i64 noundef %size1, i64 noundef %size2) #0 {
703
+ define i8* @strtok(i8* noundef %str, i8* noundef %delim) #0 {
683
704
  entry:
684
- %size1.addr = alloca i64, align 8
685
- %size2.addr = alloca i64, align 8
686
- store i64 %size1, i64* %size1.addr, align 8
687
- store i64 %size2, i64* %size2.addr, align 8
705
+ %str.addr = alloca i8*, align 8
706
+ %delim.addr = alloca i8*, align 8
707
+ store i8* %str, i8** %str.addr, align 8
708
+ store i8* %delim, i8** %delim.addr, align 8
688
709
  ret i8* null
689
710
  }
690
711
 
691
712
  ; Function Attrs: noinline nounwind ssp uwtable
692
- define i8* @valloc(i64 noundef %size) #0 {
713
+ define i8* @strtok_r(i8* noundef %str, i8* noundef %delim, i8** noundef %saveptr) #0 {
693
714
  entry:
694
- %size.addr = alloca i64, align 8
695
- store i64 %size, i64* %size.addr, align 8
715
+ %str.addr = alloca i8*, align 8
716
+ %delim.addr = alloca i8*, align 8
717
+ %saveptr.addr = alloca i8**, align 8
718
+ store i8* %str, i8** %str.addr, align 8
719
+ store i8* %delim, i8** %delim.addr, align 8
720
+ store i8** %saveptr, i8*** %saveptr.addr, align 8
696
721
  ret i8* null
697
722
  }
698
723
 
699
724
  ; Function Attrs: noinline nounwind ssp uwtable
700
- define i8* @mmap64(i8* noundef %addr, i64 noundef %len, i32 noundef %prot, i32 noundef %flags, i32 noundef %fildes, i64 noundef %off) #0 {
725
+ define i8* @xrealloc(i8* noundef %ptr, i64 noundef %bytes) #0 {
701
726
  entry:
702
- %addr.addr = alloca i8*, align 8
703
- %len.addr = alloca i64, align 8
704
- %prot.addr = alloca i32, align 4
705
- %flags.addr = alloca i32, align 4
706
- %fildes.addr = alloca i32, align 4
707
- %off.addr = alloca i64, align 8
708
- store i8* %addr, i8** %addr.addr, align 8
709
- store i64 %len, i64* %len.addr, align 8
710
- store i32 %prot, i32* %prot.addr, align 4
711
- store i32 %flags, i32* %flags.addr, align 4
712
- store i32 %fildes, i32* %fildes.addr, align 4
713
- store i64 %off, i64* %off.addr, align 8
727
+ %ptr.addr = alloca i8*, align 8
728
+ %bytes.addr = alloca i64, align 8
729
+ store i8* %ptr, i8** %ptr.addr, align 8
730
+ store i64 %bytes, i64* %bytes.addr, align 8
714
731
  ret i8* null
715
732
  }
716
733
 
717
734
  ; Function Attrs: noinline nounwind ssp uwtable
718
- define i8* @XSetLocaleModifiers(i8* noundef %a) #0 {
735
+ define i8* @_Znwm(i64 noundef %size) #0 {
719
736
  entry:
720
- %a.addr = alloca i8*, align 8
721
- store i8* %a, i8** %a.addr, align 8
737
+ %size.addr = alloca i64, align 8
738
+ store i64 %size, i64* %size.addr, align 8
722
739
  ret i8* null
723
740
  }
724
741
 
725
742
  ; Function Attrs: noinline nounwind ssp uwtable
726
- define i8* @__strdup(i8* noundef %string) #0 {
743
+ define i8* @_ZnwmRKSt9nothrow_t(i64 noundef %size, i8* noundef %0) #0 {
727
744
  entry:
728
- %string.addr = alloca i8*, align 8
729
- store i8* %string, i8** %string.addr, align 8
745
+ %size.addr = alloca i64, align 8
746
+ %.addr = alloca i8*, align 8
747
+ store i64 %size, i64* %size.addr, align 8
748
+ store i8* %0, i8** %.addr, align 8
730
749
  ret i8* null
731
750
  }
732
751
 
733
752
  ; Function Attrs: noinline nounwind ssp uwtable
734
- define i8* @crypt(i8* noundef %key, i8* noundef %salt) #0 {
753
+ define i8* @_ZnamRKSt9nothrow_t(i64 noundef %size, i8* noundef %0) #0 {
735
754
  entry:
736
- %key.addr = alloca i8*, align 8
737
- %salt.addr = alloca i8*, align 8
738
- store i8* %key, i8** %key.addr, align 8
739
- store i8* %salt, i8** %salt.addr, align 8
755
+ %size.addr = alloca i64, align 8
756
+ %.addr = alloca i8*, align 8
757
+ store i64 %size, i64* %size.addr, align 8
758
+ store i8* %0, i8** %.addr, align 8
740
759
  ret i8* null
741
760
  }
742
761
 
743
762
  ; Function Attrs: noinline nounwind ssp uwtable
744
- define i8* @ctime(i8* noundef %timer) #0 {
763
+ define i32 @asprintf(i8** noalias noundef %strp, i8* noalias noundef %fmt, ...) #0 {
745
764
  entry:
746
- %timer.addr = alloca i8*, align 8
747
- store i8* %timer, i8** %timer.addr, align 8
748
- ret i8* null
765
+ %strp.addr = alloca i8**, align 8
766
+ %fmt.addr = alloca i8*, align 8
767
+ store i8** %strp, i8*** %strp.addr, align 8
768
+ store i8* %fmt, i8** %fmt.addr, align 8
769
+ ret i32 0
749
770
  }
750
771
 
751
772
  ; Function Attrs: noinline nounwind ssp uwtable
752
- define i8* @dlerror() #0 {
773
+ define i32 @vasprintf(i8** noundef %strp, i8* noundef %fmt, i8* noundef %ap) #0 {
753
774
  entry:
754
- ret i8* null
775
+ %strp.addr = alloca i8**, align 8
776
+ %fmt.addr = alloca i8*, align 8
777
+ %ap.addr = alloca i8*, align 8
778
+ store i8** %strp, i8*** %strp.addr, align 8
779
+ store i8* %fmt, i8** %fmt.addr, align 8
780
+ store i8* %ap, i8** %ap.addr, align 8
781
+ ret i32 0
755
782
  }
756
783
 
757
784
  ; Function Attrs: noinline nounwind ssp uwtable
758
- define i8* @dlopen(i8* noundef %voidname, i32 noundef %flags) #0 {
785
+ define i32 @db_create(i8** noundef %dbp, i8* noundef %dbenv, i32 noundef %flags) #0 {
759
786
  entry:
760
- %voidname.addr = alloca i8*, align 8
787
+ %dbp.addr = alloca i8**, align 8
788
+ %dbenv.addr = alloca i8*, align 8
761
789
  %flags.addr = alloca i32, align 4
762
- store i8* %voidname, i8** %voidname.addr, align 8
790
+ store i8** %dbp, i8*** %dbp.addr, align 8
791
+ store i8* %dbenv, i8** %dbenv.addr, align 8
763
792
  store i32 %flags, i32* %flags.addr, align 4
764
- ret i8* null
793
+ ret i32 0
765
794
  }
766
795
 
767
796
  ; Function Attrs: noinline nounwind ssp uwtable
768
- define i8* @gai_strerror(i32 noundef %errcode) #0 {
797
+ define i32 @gnutls_pkcs12_bag_init(i8* noundef %a) #0 {
769
798
  entry:
770
- %errcode.addr = alloca i32, align 4
771
- store i32 %errcode, i32* %errcode.addr, align 4
772
- ret i8* null
799
+ %a.addr = alloca i8*, align 8
800
+ store i8* %a, i8** %a.addr, align 8
801
+ ret i32 0
773
802
  }
774
803
 
775
804
  ; Function Attrs: noinline nounwind ssp uwtable
776
- define i8* @gcry_cipher_algo_name(i32 noundef %errcode) #0 {
805
+ define i32 @gnutls_pkcs12_init(i8* noundef %a) #0 {
777
806
  entry:
778
- %errcode.addr = alloca i32, align 4
779
- store i32 %errcode, i32* %errcode.addr, align 4
780
- ret i8* null
807
+ %a.addr = alloca i8*, align 8
808
+ store i8* %a, i8** %a.addr, align 8
809
+ ret i32 0
781
810
  }
782
811
 
783
812
  ; Function Attrs: noinline nounwind ssp uwtable
784
- define i8* @svfgcry_md_algo_name_(i32 noundef %errcode) #0 {
813
+ define i32 @gnutls_x509_crt_init(i8* noundef %a) #0 {
785
814
  entry:
786
- %errcode.addr = alloca i32, align 4
787
- store i32 %errcode, i32* %errcode.addr, align 4
788
- ret i8* null
815
+ %a.addr = alloca i8*, align 8
816
+ store i8* %a, i8** %a.addr, align 8
817
+ ret i32 0
789
818
  }
790
819
 
791
820
  ; Function Attrs: noinline nounwind ssp uwtable
792
- define i8* @getenv(i8* noundef %name) #0 {
821
+ define i32 @gnutls_x509_privkey_init(i8* noundef %a) #0 {
793
822
  entry:
794
- %name.addr = alloca i8*, align 8
795
- store i8* %name, i8** %name.addr, align 8
796
- ret i8* null
823
+ %a.addr = alloca i8*, align 8
824
+ store i8* %a, i8** %a.addr, align 8
825
+ ret i32 0
797
826
  }
798
827
 
799
828
  ; Function Attrs: noinline nounwind ssp uwtable
800
- define i8* @getlogin() #0 {
829
+ define i32 @posix_memalign(i8** noundef %a, i64 noundef %b, i64 noundef %c) #0 {
801
830
  entry:
802
- ret i8* null
831
+ %a.addr = alloca i8**, align 8
832
+ %b.addr = alloca i64, align 8
833
+ %c.addr = alloca i64, align 8
834
+ store i8** %a, i8*** %a.addr, align 8
835
+ store i64 %b, i64* %b.addr, align 8
836
+ store i64 %c, i64* %c.addr, align 8
837
+ ret i32 0
803
838
  }
804
839
 
805
840
  ; Function Attrs: noinline nounwind ssp uwtable
806
- define i8* @getpass(i8* noundef %prompt) #0 {
841
+ define i32 @scandir(i8* noalias noundef %dirp, %struct.dirent*** noalias noundef %namelist, i32 (%struct.dirent*)* noundef %filter, i32 (%struct.dirent**, %struct.dirent**)* noundef %compar) #0 {
807
842
  entry:
808
- %prompt.addr = alloca i8*, align 8
809
- store i8* %prompt, i8** %prompt.addr, align 8
810
- ret i8* null
843
+ %dirp.addr = alloca i8*, align 8
844
+ %namelist.addr = alloca %struct.dirent***, align 8
845
+ %filter.addr = alloca i32 (%struct.dirent*)*, align 8
846
+ %compar.addr = alloca i32 (%struct.dirent**, %struct.dirent**)*, align 8
847
+ store i8* %dirp, i8** %dirp.addr, align 8
848
+ store %struct.dirent*** %namelist, %struct.dirent**** %namelist.addr, align 8
849
+ store i32 (%struct.dirent*)* %filter, i32 (%struct.dirent*)** %filter.addr, align 8
850
+ store i32 (%struct.dirent**, %struct.dirent**)* %compar, i32 (%struct.dirent**, %struct.dirent**)** %compar.addr, align 8
851
+ ret i32 0
811
852
  }
812
853
 
813
854
  ; Function Attrs: noinline nounwind ssp uwtable
814
- define i8* @gnutls_strerror(i32 noundef %error) #0 {
855
+ define i32 @XmbTextPropertyToTextList(i8* noundef %a, i8* noundef %b, i8*** noundef %c, i32* noundef %d) #0 {
815
856
  entry:
816
- %error.addr = alloca i32, align 4
817
- store i32 %error, i32* %error.addr, align 4
818
- ret i8* null
857
+ %a.addr = alloca i8*, align 8
858
+ %b.addr = alloca i8*, align 8
859
+ %c.addr = alloca i8***, align 8
860
+ %d.addr = alloca i32*, align 8
861
+ store i8* %a, i8** %a.addr, align 8
862
+ store i8* %b, i8** %b.addr, align 8
863
+ store i8*** %c, i8**** %c.addr, align 8
864
+ store i32* %d, i32** %d.addr, align 8
865
+ ret i32 0
819
866
  }
820
867
 
821
868
  ; Function Attrs: noinline nounwind ssp uwtable
822
- define i8* @gpg_strerror(i32 noundef %a) #0 {
869
+ define void @llvm_memcpy_p0i8_p0i8_i64(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
823
870
  entry:
824
- %a.addr = alloca i32, align 4
825
- store i32 %a, i32* %a.addr, align 4
826
- ret i8* null
827
- }
871
+ %dst.addr = alloca i8*, align 8
872
+ %src.addr = alloca i8*, align 8
873
+ %sz.addr = alloca i32, align 4
874
+ %flag.addr = alloca i32, align 4
875
+ store i8* %dst, i8** %dst.addr, align 8
876
+ store i8* %src, i8** %src.addr, align 8
877
+ store i32 %sz, i32* %sz.addr, align 4
878
+ store i32 %flag, i32* %flag.addr, align 4
879
+ ret void
880
+ }
828
881
 
829
882
  ; Function Attrs: noinline nounwind ssp uwtable
830
- define i8* @gzerror(i8* noundef %file, i32* noundef %errnum) #0 {
883
+ define void @llvm_memcpy_p0i8_p0i8_i32(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
831
884
  entry:
832
- %file.addr = alloca i8*, align 8
833
- %errnum.addr = alloca i32*, align 8
834
- store i8* %file, i8** %file.addr, align 8
835
- store i32* %errnum, i32** %errnum.addr, align 8
836
- ret i8* null
885
+ %dst.addr = alloca i8*, align 8
886
+ %src.addr = alloca i8*, align 8
887
+ %sz.addr = alloca i32, align 4
888
+ %flag.addr = alloca i32, align 4
889
+ store i8* %dst, i8** %dst.addr, align 8
890
+ store i8* %src, i8** %src.addr, align 8
891
+ store i32 %sz, i32* %sz.addr, align 4
892
+ store i32 %flag, i32* %flag.addr, align 4
893
+ ret void
837
894
  }
838
895
 
839
896
  ; Function Attrs: noinline nounwind ssp uwtable
840
- define i8* @inet_ntoa(i32 noundef %in) #0 {
897
+ define void @llvm_memcpy(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
841
898
  entry:
842
- %in.addr = alloca i32, align 4
843
- store i32 %in, i32* %in.addr, align 4
844
- ret i8* null
899
+ %dst.addr = alloca i8*, align 8
900
+ %src.addr = alloca i8*, align 8
901
+ %sz.addr = alloca i32, align 4
902
+ %flag.addr = alloca i32, align 4
903
+ store i8* %dst, i8** %dst.addr, align 8
904
+ store i8* %src, i8** %src.addr, align 8
905
+ store i32 %sz, i32* %sz.addr, align 4
906
+ store i32 %flag, i32* %flag.addr, align 4
907
+ ret void
845
908
  }
846
909
 
847
910
  ; Function Attrs: noinline nounwind ssp uwtable
848
- define i8* @initscr() #0 {
911
+ define void @llvm_memmove(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
849
912
  entry:
850
- ret i8* null
913
+ %dst.addr = alloca i8*, align 8
914
+ %src.addr = alloca i8*, align 8
915
+ %sz.addr = alloca i32, align 4
916
+ %flag.addr = alloca i32, align 4
917
+ store i8* %dst, i8** %dst.addr, align 8
918
+ store i8* %src, i8** %src.addr, align 8
919
+ store i32 %sz, i32* %sz.addr, align 4
920
+ store i32 %flag, i32* %flag.addr, align 4
921
+ ret void
851
922
  }
852
923
 
853
924
  ; Function Attrs: noinline nounwind ssp uwtable
854
- define i8* @llvm_stacksave() #0 {
925
+ define void @llvm_memmove_p0i8_p0i8_i64(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
855
926
  entry:
856
- ret i8* null
927
+ %dst.addr = alloca i8*, align 8
928
+ %src.addr = alloca i8*, align 8
929
+ %sz.addr = alloca i32, align 4
930
+ %flag.addr = alloca i32, align 4
931
+ store i8* %dst, i8** %dst.addr, align 8
932
+ store i8* %src, i8** %src.addr, align 8
933
+ store i32 %sz, i32* %sz.addr, align 4
934
+ store i32 %flag, i32* %flag.addr, align 4
935
+ ret void
857
936
  }
858
937
 
859
938
  ; Function Attrs: noinline nounwind ssp uwtable
860
- define i8* @mmap(i8* noundef %addr, i64 noundef %len, i32 noundef %prot, i32 noundef %flags, i32 noundef %fildes, i64 noundef %off) #0 {
939
+ define void @llvm_memmove_p0i8_p0i8_i32(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
861
940
  entry:
862
- %addr.addr = alloca i8*, align 8
863
- %len.addr = alloca i64, align 8
864
- %prot.addr = alloca i32, align 4
865
- %flags.addr = alloca i32, align 4
866
- %fildes.addr = alloca i32, align 4
867
- %off.addr = alloca i64, align 8
868
- store i8* %addr, i8** %addr.addr, align 8
869
- store i64 %len, i64* %len.addr, align 8
870
- store i32 %prot, i32* %prot.addr, align 4
871
- store i32 %flags, i32* %flags.addr, align 4
872
- store i32 %fildes, i32* %fildes.addr, align 4
873
- store i64 %off, i64* %off.addr, align 8
874
- ret i8* null
941
+ %dst.addr = alloca i8*, align 8
942
+ %src.addr = alloca i8*, align 8
943
+ %sz.addr = alloca i32, align 4
944
+ %flag.addr = alloca i32, align 4
945
+ store i8* %dst, i8** %dst.addr, align 8
946
+ store i8* %src, i8** %src.addr, align 8
947
+ store i32 %sz, i32* %sz.addr, align 4
948
+ store i32 %flag, i32* %flag.addr, align 4
949
+ ret void
875
950
  }
876
951
 
877
952
  ; Function Attrs: noinline nounwind ssp uwtable
878
- define i8* @newwin(i32 noundef %nlines, i32 noundef %ncols, i32 noundef %begin_y, i32 noundef %begin_x) #0 {
953
+ define void @__memcpy_chk(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
879
954
  entry:
880
- %nlines.addr = alloca i32, align 4
881
- %ncols.addr = alloca i32, align 4
882
- %begin_y.addr = alloca i32, align 4
883
- %begin_x.addr = alloca i32, align 4
884
- store i32 %nlines, i32* %nlines.addr, align 4
885
- store i32 %ncols, i32* %ncols.addr, align 4
886
- store i32 %begin_y, i32* %begin_y.addr, align 4
887
- store i32 %begin_x, i32* %begin_x.addr, align 4
888
- ret i8* null
955
+ %dst.addr = alloca i8*, align 8
956
+ %src.addr = alloca i8*, align 8
957
+ %sz.addr = alloca i32, align 4
958
+ %flag.addr = alloca i32, align 4
959
+ store i8* %dst, i8** %dst.addr, align 8
960
+ store i8* %src, i8** %src.addr, align 8
961
+ store i32 %sz, i32* %sz.addr, align 4
962
+ store i32 %flag, i32* %flag.addr, align 4
963
+ ret void
889
964
  }
890
965
 
891
966
  ; Function Attrs: noinline nounwind ssp uwtable
892
- define i8* @nl_langinfo(i32 noundef %item) #0 {
967
+ define i8* @memmove(i8* noundef %str1, i8* noundef %str2, i64 noundef %n) #0 {
893
968
  entry:
894
- %item.addr = alloca i32, align 4
895
- store i32 %item, i32* %item.addr, align 4
969
+ %str1.addr = alloca i8*, align 8
970
+ %str2.addr = alloca i8*, align 8
971
+ %n.addr = alloca i64, align 8
972
+ store i8* %str1, i8** %str1.addr, align 8
973
+ store i8* %str2, i8** %str2.addr, align 8
974
+ store i64 %n, i64* %n.addr, align 8
896
975
  ret i8* null
897
976
  }
898
977
 
899
978
  ; Function Attrs: noinline nounwind ssp uwtable
900
- define i8* @opendir(i8* noundef %name) #0 {
979
+ define void @bcopy(i8* noundef %s1, i8* noundef %s2, i64 noundef %n) #0 {
901
980
  entry:
902
- %name.addr = alloca i8*, align 8
903
- store i8* %name, i8** %name.addr, align 8
904
- ret i8* null
981
+ %s1.addr = alloca i8*, align 8
982
+ %s2.addr = alloca i8*, align 8
983
+ %n.addr = alloca i64, align 8
984
+ store i8* %s1, i8** %s1.addr, align 8
985
+ store i8* %s2, i8** %s2.addr, align 8
986
+ store i64 %n, i64* %n.addr, align 8
987
+ ret void
905
988
  }
906
989
 
907
990
  ; Function Attrs: noinline nounwind ssp uwtable
908
- define i8* @sbrk(i64 noundef %increment) #0 {
991
+ define i8* @memccpy(i8* noalias noundef %dest, i8* noalias noundef %src, i32 noundef %c, i64 noundef %count) #0 {
909
992
  entry:
910
- %increment.addr = alloca i64, align 8
911
- store i64 %increment, i64* %increment.addr, align 8
993
+ %dest.addr = alloca i8*, align 8
994
+ %src.addr = alloca i8*, align 8
995
+ %c.addr = alloca i32, align 4
996
+ %count.addr = alloca i64, align 8
997
+ store i8* %dest, i8** %dest.addr, align 8
998
+ store i8* %src, i8** %src.addr, align 8
999
+ store i32 %c, i32* %c.addr, align 4
1000
+ store i64 %count, i64* %count.addr, align 8
912
1001
  ret i8* null
913
1002
  }
914
1003
 
915
1004
  ; Function Attrs: noinline nounwind ssp uwtable
916
- define i8* @strdup(i8* noundef %s) #0 {
1005
+ define void @__memmove_chk(i8* noundef %dst, i8* noundef %src, i32 noundef %sz) #0 {
917
1006
  entry:
918
- %s.addr = alloca i8*, align 8
919
- store i8* %s, i8** %s.addr, align 8
920
- ret i8* null
1007
+ %dst.addr = alloca i8*, align 8
1008
+ %src.addr = alloca i8*, align 8
1009
+ %sz.addr = alloca i32, align 4
1010
+ store i8* %dst, i8** %dst.addr, align 8
1011
+ store i8* %src, i8** %src.addr, align 8
1012
+ store i32 %sz, i32* %sz.addr, align 4
1013
+ ret void
921
1014
  }
922
1015
 
923
1016
  ; Function Attrs: noinline nounwind ssp uwtable
924
- define i8* @strerror(i32 noundef %errnum) #0 {
1017
+ define void @llvm_memset(i8* noundef %dst, i8 noundef signext %elem, i32 noundef %sz, i32 noundef %flag) #0 {
925
1018
  entry:
926
- %errnum.addr = alloca i32, align 4
927
- store i32 %errnum, i32* %errnum.addr, align 4
928
- ret i8* null
1019
+ %dst.addr = alloca i8*, align 8
1020
+ %elem.addr = alloca i8, align 1
1021
+ %sz.addr = alloca i32, align 4
1022
+ %flag.addr = alloca i32, align 4
1023
+ store i8* %dst, i8** %dst.addr, align 8
1024
+ store i8 %elem, i8* %elem.addr, align 1
1025
+ store i32 %sz, i32* %sz.addr, align 4
1026
+ store i32 %flag, i32* %flag.addr, align 4
1027
+ ret void
929
1028
  }
930
1029
 
931
1030
  ; Function Attrs: noinline nounwind ssp uwtable
932
- define i8* @strsignal(i32 noundef %errnum) #0 {
1031
+ define void @llvm_memset_p0i8_i32(i8* noundef %dst, i8 noundef signext %elem, i32 noundef %sz, i32 noundef %flag) #0 {
933
1032
  entry:
934
- %errnum.addr = alloca i32, align 4
935
- store i32 %errnum, i32* %errnum.addr, align 4
936
- ret i8* null
1033
+ %dst.addr = alloca i8*, align 8
1034
+ %elem.addr = alloca i8, align 1
1035
+ %sz.addr = alloca i32, align 4
1036
+ %flag.addr = alloca i32, align 4
1037
+ store i8* %dst, i8** %dst.addr, align 8
1038
+ store i8 %elem, i8* %elem.addr, align 1
1039
+ store i32 %sz, i32* %sz.addr, align 4
1040
+ store i32 %flag, i32* %flag.addr, align 4
1041
+ ret void
937
1042
  }
938
1043
 
939
1044
  ; Function Attrs: noinline nounwind ssp uwtable
940
- define i8* @textdomain(i8* noundef %domainname) #0 {
1045
+ define void @llvm_memset_p0i8_i64(i8* noundef %dst, i8 noundef signext %elem, i32 noundef %sz, i32 noundef %flag) #0 {
941
1046
  entry:
942
- %domainname.addr = alloca i8*, align 8
943
- store i8* %domainname, i8** %domainname.addr, align 8
944
- ret i8* null
1047
+ %dst.addr = alloca i8*, align 8
1048
+ %elem.addr = alloca i8, align 1
1049
+ %sz.addr = alloca i32, align 4
1050
+ %flag.addr = alloca i32, align 4
1051
+ store i8* %dst, i8** %dst.addr, align 8
1052
+ store i8 %elem, i8* %elem.addr, align 1
1053
+ store i32 %sz, i32* %sz.addr, align 4
1054
+ store i32 %flag, i32* %flag.addr, align 4
1055
+ ret void
945
1056
  }
946
1057
 
947
1058
  ; Function Attrs: noinline nounwind ssp uwtable
948
- define i8* @tgetstr(i8* noundef %id, i8** noundef %area) #0 {
1059
+ define i8* @__memset_chk(i8* noundef %dest, i32 noundef %c, i64 noundef %destlen, i32 noundef %flag) #0 {
949
1060
  entry:
950
- %id.addr = alloca i8*, align 8
951
- %area.addr = alloca i8**, align 8
952
- store i8* %id, i8** %id.addr, align 8
953
- store i8** %area, i8*** %area.addr, align 8
1061
+ %dest.addr = alloca i8*, align 8
1062
+ %c.addr = alloca i32, align 4
1063
+ %destlen.addr = alloca i64, align 8
1064
+ %flag.addr = alloca i32, align 4
1065
+ store i8* %dest, i8** %dest.addr, align 8
1066
+ store i32 %c, i32* %c.addr, align 4
1067
+ store i64 %destlen, i64* %destlen.addr, align 8
1068
+ store i32 %flag, i32* %flag.addr, align 4
954
1069
  ret i8* null
955
1070
  }
956
1071
 
957
1072
  ; Function Attrs: noinline nounwind ssp uwtable
958
- define i8* @tigetstr(i8* noundef %capname) #0 {
1073
+ define i8* @__strcpy_chk(i8* noundef %dest, i8* noundef %src, i64 noundef %destlen) #0 {
959
1074
  entry:
960
- %capname.addr = alloca i8*, align 8
961
- store i8* %capname, i8** %capname.addr, align 8
1075
+ %dest.addr = alloca i8*, align 8
1076
+ %src.addr = alloca i8*, align 8
1077
+ %destlen.addr = alloca i64, align 8
1078
+ store i8* %dest, i8** %dest.addr, align 8
1079
+ store i8* %src, i8** %src.addr, align 8
1080
+ store i64 %destlen, i64* %destlen.addr, align 8
962
1081
  ret i8* null
963
1082
  }
964
1083
 
965
1084
  ; Function Attrs: noinline nounwind ssp uwtable
966
- define i8* @tmpnam(i8* noundef %s) #0 {
1085
+ define i8* @__strcat_chk(i8* noundef %dest, i8* noundef %src, i64 noundef %destlen) #0 {
967
1086
  entry:
968
- %s.addr = alloca i8*, align 8
969
- store i8* %s, i8** %s.addr, align 8
1087
+ %dest.addr = alloca i8*, align 8
1088
+ %src.addr = alloca i8*, align 8
1089
+ %destlen.addr = alloca i64, align 8
1090
+ store i8* %dest, i8** %dest.addr, align 8
1091
+ store i8* %src, i8** %src.addr, align 8
1092
+ store i64 %destlen, i64* %destlen.addr, align 8
970
1093
  ret i8* null
971
1094
  }
972
1095
 
973
1096
  ; Function Attrs: noinline nounwind ssp uwtable
974
- define i8* @ttyname(i32 noundef %fd) #0 {
1097
+ define i8* @stpcpy(i8* noalias noundef %dst, i8* noalias noundef %src) #0 {
975
1098
  entry:
976
- %fd.addr = alloca i32, align 4
977
- store i32 %fd, i32* %fd.addr, align 4
1099
+ %dst.addr = alloca i8*, align 8
1100
+ %src.addr = alloca i8*, align 8
1101
+ store i8* %dst, i8** %dst.addr, align 8
1102
+ store i8* %src, i8** %src.addr, align 8
978
1103
  ret i8* null
979
1104
  }
980
1105
 
981
1106
  ; Function Attrs: noinline nounwind ssp uwtable
982
- define i8* @malloc(i64 noundef %size) #0 {
1107
+ define i8* @strcat(i8* noundef %dest, i8* noundef %src) #0 {
983
1108
  entry:
984
- %size.addr = alloca i64, align 8
985
- store i64 %size, i64* %size.addr, align 8
1109
+ %dest.addr = alloca i8*, align 8
1110
+ %src.addr = alloca i8*, align 8
1111
+ store i8* %dest, i8** %dest.addr, align 8
1112
+ store i8* %src, i8** %src.addr, align 8
986
1113
  ret i8* null
987
1114
  }
988
1115
 
989
1116
  ; Function Attrs: noinline nounwind ssp uwtable
990
- define i8* @getcwd(i8* noundef %buf, i64 noundef %size) #0 {
1117
+ define i8* @strcpy(i8* noundef %dest, i8* noundef %src) #0 {
991
1118
  entry:
992
- %buf.addr = alloca i8*, align 8
993
- %size.addr = alloca i64, align 8
994
- store i8* %buf, i8** %buf.addr, align 8
995
- store i64 %size, i64* %size.addr, align 8
1119
+ %dest.addr = alloca i8*, align 8
1120
+ %src.addr = alloca i8*, align 8
1121
+ store i8* %dest, i8** %dest.addr, align 8
1122
+ store i8* %src, i8** %src.addr, align 8
996
1123
  ret i8* null
997
1124
  }
998
1125
 
999
1126
  ; Function Attrs: noinline nounwind ssp uwtable
1000
- define i8* @mem_realloc(i8* noundef %ptr, i64 noundef %size) #0 {
1001
- entry:
1002
- %ptr.addr = alloca i8*, align 8
1003
- %size.addr = alloca i64, align 8
1004
- store i8* %ptr, i8** %ptr.addr, align 8
1005
- store i64 %size, i64* %size.addr, align 8
1006
- ret i8* null
1007
- }
1008
-
1009
- ; Function Attrs: noinline nounwind ssp uwtable
1010
- define i8* @realloc(i8* noundef %ptr, i64 noundef %size) #0 {
1127
+ define i8* @strncat(i8* noundef %dest, i8* noundef %src, i64 noundef %n) #0 {
1011
1128
  entry:
1012
- %ptr.addr = alloca i8*, align 8
1013
- %size.addr = alloca i64, align 8
1014
- store i8* %ptr, i8** %ptr.addr, align 8
1015
- store i64 %size, i64* %size.addr, align 8
1129
+ %dest.addr = alloca i8*, align 8
1130
+ %src.addr = alloca i8*, align 8
1131
+ %n.addr = alloca i64, align 8
1132
+ store i8* %dest, i8** %dest.addr, align 8
1133
+ store i8* %src, i8** %src.addr, align 8
1134
+ store i64 %n, i64* %n.addr, align 8
1016
1135
  ret i8* null
1017
1136
  }
1018
1137
 
1019
1138
  ; Function Attrs: noinline nounwind ssp uwtable
1020
- define i8* @safe_realloc(i8* noundef %p, i64 noundef %n) #0 {
1139
+ define i8* @strncpy(i8* noundef %dest, i8* noundef %src, i64 noundef %n) #0 {
1021
1140
  entry:
1022
- %p.addr = alloca i8*, align 8
1141
+ %dest.addr = alloca i8*, align 8
1142
+ %src.addr = alloca i8*, align 8
1023
1143
  %n.addr = alloca i64, align 8
1024
- store i8* %p, i8** %p.addr, align 8
1144
+ store i8* %dest, i8** %dest.addr, align 8
1145
+ store i8* %src, i8** %src.addr, align 8
1025
1146
  store i64 %n, i64* %n.addr, align 8
1026
1147
  ret i8* null
1027
1148
  }
1028
1149
 
1029
1150
  ; Function Attrs: noinline nounwind ssp uwtable
1030
- define i8* @saferealloc(i8* noundef %p, i64 noundef %n1, i64 noundef %n2) #0 {
1151
+ define i64 @iconv(i8* noundef %cd, i8** noalias noundef %inbuf, i64* noalias noundef %inbytesleft, i8** noalias noundef %outbuf, i64* noalias noundef %outbytesleft) #0 {
1031
1152
  entry:
1032
- %p.addr = alloca i8*, align 8
1033
- %n1.addr = alloca i64, align 8
1034
- %n2.addr = alloca i64, align 8
1035
- store i8* %p, i8** %p.addr, align 8
1036
- store i64 %n1, i64* %n1.addr, align 8
1037
- store i64 %n2, i64* %n2.addr, align 8
1038
- ret i8* null
1153
+ %cd.addr = alloca i8*, align 8
1154
+ %inbuf.addr = alloca i8**, align 8
1155
+ %inbytesleft.addr = alloca i64*, align 8
1156
+ %outbuf.addr = alloca i8**, align 8
1157
+ %outbytesleft.addr = alloca i64*, align 8
1158
+ store i8* %cd, i8** %cd.addr, align 8
1159
+ store i8** %inbuf, i8*** %inbuf.addr, align 8
1160
+ store i64* %inbytesleft, i64** %inbytesleft.addr, align 8
1161
+ store i8** %outbuf, i8*** %outbuf.addr, align 8
1162
+ store i64* %outbytesleft, i64** %outbytesleft.addr, align 8
1163
+ ret i64 0
1039
1164
  }
1040
1165
 
1041
1166
  ; Function Attrs: noinline nounwind ssp uwtable
1042
- define i8* @safexrealloc() #0 {
1167
+ define i8* @_ZNSt5arrayIPK1ALm2EE4backEv(i8* noundef %arg) #0 {
1043
1168
  entry:
1044
- ret i8* null
1169
+ %arg.addr = alloca i8*, align 8
1170
+ %ptr1 = alloca i8*, align 8
1171
+ %ptr2 = alloca i8*, align 8
1172
+ store i8* %arg, i8** %arg.addr, align 8
1173
+ %0 = load i8*, i8** %arg.addr, align 8
1174
+ %add.ptr = getelementptr inbounds i8, i8* %0, i64 0
1175
+ store i8* %add.ptr, i8** %ptr1, align 8
1176
+ %1 = load i8*, i8** %ptr1, align 8
1177
+ %add.ptr1 = getelementptr inbounds i8, i8* %1, i64 0
1178
+ store i8* %add.ptr1, i8** %ptr2, align 8
1179
+ %2 = load i8*, i8** %ptr2, align 8
1180
+ ret i8* %2
1045
1181
  }
1046
1182
 
1047
1183
  ; Function Attrs: noinline nounwind ssp uwtable
1048
- define i8* @strtok(i8* noundef %str, i8* noundef %delim) #0 {
1184
+ define i8* @SyGetmem(i64 noundef %size) #0 {
1049
1185
  entry:
1050
- %str.addr = alloca i8*, align 8
1051
- %delim.addr = alloca i8*, align 8
1052
- store i8* %str, i8** %str.addr, align 8
1053
- store i8* %delim, i8** %delim.addr, align 8
1186
+ %size.addr = alloca i64, align 8
1187
+ store i64 %size, i64* %size.addr, align 8
1054
1188
  ret i8* null
1055
1189
  }
1056
1190
 
1057
1191
  ; Function Attrs: noinline nounwind ssp uwtable
1058
- define i8* @strtok_r(i8* noundef %str, i8* noundef %delim, i8** noundef %saveptr) #0 {
1192
+ define i8* @__rawmemchr(i8* noundef %s, i32 noundef %c) #0 {
1059
1193
  entry:
1060
- %str.addr = alloca i8*, align 8
1061
- %delim.addr = alloca i8*, align 8
1062
- %saveptr.addr = alloca i8**, align 8
1063
- store i8* %str, i8** %str.addr, align 8
1064
- store i8* %delim, i8** %delim.addr, align 8
1065
- store i8** %saveptr, i8*** %saveptr.addr, align 8
1066
- ret i8* null
1194
+ %s.addr = alloca i8*, align 8
1195
+ %c.addr = alloca i32, align 4
1196
+ store i8* %s, i8** %s.addr, align 8
1197
+ store i32 %c, i32* %c.addr, align 4
1198
+ %0 = load i8*, i8** %s.addr, align 8
1199
+ ret i8* %0
1067
1200
  }
1068
1201
 
1069
1202
  ; Function Attrs: noinline nounwind ssp uwtable
1070
- define i8* @xrealloc(i8* noundef %ptr, i64 noundef %bytes) #0 {
1203
+ define %struct.jpeg_error_mgr* @jpeg_std_error(%struct.jpeg_error_mgr* noundef %a) #0 {
1071
1204
  entry:
1072
- %ptr.addr = alloca i8*, align 8
1073
- %bytes.addr = alloca i64, align 8
1074
- store i8* %ptr, i8** %ptr.addr, align 8
1075
- store i64 %bytes, i64* %bytes.addr, align 8
1076
- ret i8* null
1205
+ %a.addr = alloca %struct.jpeg_error_mgr*, align 8
1206
+ store %struct.jpeg_error_mgr* %a, %struct.jpeg_error_mgr** %a.addr, align 8
1207
+ %0 = load %struct.jpeg_error_mgr*, %struct.jpeg_error_mgr** %a.addr, align 8
1208
+ ret %struct.jpeg_error_mgr* %0
1077
1209
  }
1078
1210
 
1079
1211
  ; Function Attrs: noinline nounwind ssp uwtable
1080
- define i8* @_Znwm(i64 noundef %size) #0 {
1212
+ define i8* @fgets(i8* noundef %str, i32 noundef %n, i8* noundef %stream) #0 {
1081
1213
  entry:
1082
- %size.addr = alloca i64, align 8
1083
- store i64 %size, i64* %size.addr, align 8
1084
- ret i8* null
1214
+ %str.addr = alloca i8*, align 8
1215
+ %n.addr = alloca i32, align 4
1216
+ %stream.addr = alloca i8*, align 8
1217
+ store i8* %str, i8** %str.addr, align 8
1218
+ store i32 %n, i32* %n.addr, align 4
1219
+ store i8* %stream, i8** %stream.addr, align 8
1220
+ %0 = load i8*, i8** %str.addr, align 8
1221
+ ret i8* %0
1085
1222
  }
1086
1223
 
1087
1224
  ; Function Attrs: noinline nounwind ssp uwtable
1088
- define i8* @_ZnwmRKSt9nothrow_t(i64 noundef %size, i8* noundef %0) #0 {
1225
+ define i8* @memchr(i8* noundef %str, i32 noundef %c, i64 noundef %n) #0 {
1089
1226
  entry:
1090
- %size.addr = alloca i64, align 8
1091
- %.addr = alloca i8*, align 8
1092
- store i64 %size, i64* %size.addr, align 8
1093
- store i8* %0, i8** %.addr, align 8
1094
- ret i8* null
1227
+ %str.addr = alloca i8*, align 8
1228
+ %c.addr = alloca i32, align 4
1229
+ %n.addr = alloca i64, align 8
1230
+ store i8* %str, i8** %str.addr, align 8
1231
+ store i32 %c, i32* %c.addr, align 4
1232
+ store i64 %n, i64* %n.addr, align 8
1233
+ %0 = load i8*, i8** %str.addr, align 8
1234
+ ret i8* %0
1095
1235
  }
1096
1236
 
1097
1237
  ; Function Attrs: noinline nounwind ssp uwtable
1098
- define i8* @_ZnamRKSt9nothrow_t(i64 noundef %size, i8* noundef %0) #0 {
1238
+ define i8* @mremap(i8* noundef %old_address, i64 noundef %old_size, i64 noundef %new_size, i32 noundef %flags) #0 {
1099
1239
  entry:
1100
- %size.addr = alloca i64, align 8
1101
- %.addr = alloca i8*, align 8
1102
- store i64 %size, i64* %size.addr, align 8
1103
- store i8* %0, i8** %.addr, align 8
1104
- ret i8* null
1240
+ %old_address.addr = alloca i8*, align 8
1241
+ %old_size.addr = alloca i64, align 8
1242
+ %new_size.addr = alloca i64, align 8
1243
+ %flags.addr = alloca i32, align 4
1244
+ store i8* %old_address, i8** %old_address.addr, align 8
1245
+ store i64 %old_size, i64* %old_size.addr, align 8
1246
+ store i64 %new_size, i64* %new_size.addr, align 8
1247
+ store i32 %flags, i32* %flags.addr, align 4
1248
+ %0 = load i8*, i8** %old_address.addr, align 8
1249
+ ret i8* %0
1105
1250
  }
1106
1251
 
1107
1252
  ; Function Attrs: noinline nounwind ssp uwtable
1108
- define i32 @asprintf(i8** noalias noundef %strp, i8* noalias noundef %fmt, ...) #0 {
1253
+ define i8* @strchr(i8* noundef %str, i32 noundef %c) #0 {
1109
1254
  entry:
1110
- %strp.addr = alloca i8**, align 8
1111
- %fmt.addr = alloca i8*, align 8
1112
- store i8** %strp, i8*** %strp.addr, align 8
1113
- store i8* %fmt, i8** %fmt.addr, align 8
1114
- ret i32 0
1255
+ %str.addr = alloca i8*, align 8
1256
+ %c.addr = alloca i32, align 4
1257
+ store i8* %str, i8** %str.addr, align 8
1258
+ store i32 %c, i32* %c.addr, align 4
1259
+ %0 = load i8*, i8** %str.addr, align 8
1260
+ ret i8* %0
1115
1261
  }
1116
1262
 
1117
1263
  ; Function Attrs: noinline nounwind ssp uwtable
1118
- define i32 @vasprintf(i8** noundef %strp, i8* noundef %fmt, i8* noundef %ap) #0 {
1264
+ define i8* @strerror_r(i32 noundef %errnum, i8* noundef %buf, i64 noundef %buflen) #0 {
1119
1265
  entry:
1120
- %strp.addr = alloca i8**, align 8
1121
- %fmt.addr = alloca i8*, align 8
1122
- %ap.addr = alloca i8*, align 8
1123
- store i8** %strp, i8*** %strp.addr, align 8
1124
- store i8* %fmt, i8** %fmt.addr, align 8
1125
- store i8* %ap, i8** %ap.addr, align 8
1126
- ret i32 0
1266
+ %errnum.addr = alloca i32, align 4
1267
+ %buf.addr = alloca i8*, align 8
1268
+ %buflen.addr = alloca i64, align 8
1269
+ store i32 %errnum, i32* %errnum.addr, align 4
1270
+ store i8* %buf, i8** %buf.addr, align 8
1271
+ store i64 %buflen, i64* %buflen.addr, align 8
1272
+ %0 = load i8*, i8** %buf.addr, align 8
1273
+ ret i8* %0
1127
1274
  }
1128
1275
 
1129
1276
  ; Function Attrs: noinline nounwind ssp uwtable
1130
- define i32 @db_create(i8** noundef %dbp, i8* noundef %dbenv, i32 noundef %flags) #0 {
1277
+ define i8* @strpbrk(i8* noundef %str1, i8* noundef %str2) #0 {
1131
1278
  entry:
1132
- %dbp.addr = alloca i8**, align 8
1133
- %dbenv.addr = alloca i8*, align 8
1134
- %flags.addr = alloca i32, align 4
1135
- store i8** %dbp, i8*** %dbp.addr, align 8
1136
- store i8* %dbenv, i8** %dbenv.addr, align 8
1137
- store i32 %flags, i32* %flags.addr, align 4
1138
- ret i32 0
1279
+ %str1.addr = alloca i8*, align 8
1280
+ %str2.addr = alloca i8*, align 8
1281
+ store i8* %str1, i8** %str1.addr, align 8
1282
+ store i8* %str2, i8** %str2.addr, align 8
1283
+ %0 = load i8*, i8** %str1.addr, align 8
1284
+ ret i8* %0
1139
1285
  }
1140
1286
 
1141
1287
  ; Function Attrs: noinline nounwind ssp uwtable
1142
- define i32 @gnutls_pkcs12_bag_init(i8* noundef %a) #0 {
1288
+ define i8* @strptime(i8* noundef %s, i8* noundef %format, i8* noundef %tm) #0 {
1143
1289
  entry:
1144
- %a.addr = alloca i8*, align 8
1145
- store i8* %a, i8** %a.addr, align 8
1146
- ret i32 0
1290
+ %s.addr = alloca i8*, align 8
1291
+ %format.addr = alloca i8*, align 8
1292
+ %tm.addr = alloca i8*, align 8
1293
+ store i8* %s, i8** %s.addr, align 8
1294
+ store i8* %format, i8** %format.addr, align 8
1295
+ store i8* %tm, i8** %tm.addr, align 8
1296
+ %0 = load i8*, i8** %s.addr, align 8
1297
+ ret i8* %0
1147
1298
  }
1148
1299
 
1149
1300
  ; Function Attrs: noinline nounwind ssp uwtable
1150
- define i32 @gnutls_pkcs12_init(i8* noundef %a) #0 {
1301
+ define i8* @strrchr(i8* noundef %str, i32 noundef %c) #0 {
1151
1302
  entry:
1152
- %a.addr = alloca i8*, align 8
1153
- store i8* %a, i8** %a.addr, align 8
1154
- ret i32 0
1303
+ %str.addr = alloca i8*, align 8
1304
+ %c.addr = alloca i32, align 4
1305
+ store i8* %str, i8** %str.addr, align 8
1306
+ store i32 %c, i32* %c.addr, align 4
1307
+ %0 = load i8*, i8** %str.addr, align 8
1308
+ ret i8* %0
1155
1309
  }
1156
1310
 
1157
1311
  ; Function Attrs: noinline nounwind ssp uwtable
1158
- define i32 @gnutls_x509_crt_init(i8* noundef %a) #0 {
1312
+ define i8* @strstr(i8* noundef %haystack, i8* noundef %needle) #0 {
1159
1313
  entry:
1160
- %a.addr = alloca i8*, align 8
1161
- store i8* %a, i8** %a.addr, align 8
1162
- ret i32 0
1314
+ %haystack.addr = alloca i8*, align 8
1315
+ %needle.addr = alloca i8*, align 8
1316
+ store i8* %haystack, i8** %haystack.addr, align 8
1317
+ store i8* %needle, i8** %needle.addr, align 8
1318
+ %0 = load i8*, i8** %haystack.addr, align 8
1319
+ ret i8* %0
1163
1320
  }
1164
1321
 
1165
1322
  ; Function Attrs: noinline nounwind ssp uwtable
1166
- define i32 @gnutls_x509_privkey_init(i8* noundef %a) #0 {
1323
+ define i8* @tmpnam_r(i8* noundef %s) #0 {
1167
1324
  entry:
1168
- %a.addr = alloca i8*, align 8
1169
- store i8* %a, i8** %a.addr, align 8
1170
- ret i32 0
1325
+ %s.addr = alloca i8*, align 8
1326
+ store i8* %s, i8** %s.addr, align 8
1327
+ %0 = load i8*, i8** %s.addr, align 8
1328
+ ret i8* %0
1171
1329
  }
1172
1330
 
1173
- ; Function Attrs: noinline nounwind ssp uwtable
1174
- define i32 @posix_memalign(i8** noundef %a, i64 noundef %b, i64 noundef %c) #0 {
1331
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1332
+ define i32 @isalnum(i32 noundef %character) #1 {
1175
1333
  entry:
1176
- %a.addr = alloca i8**, align 8
1177
- %b.addr = alloca i64, align 8
1178
- %c.addr = alloca i64, align 8
1179
- store i8** %a, i8*** %a.addr, align 8
1180
- store i64 %b, i64* %b.addr, align 8
1181
- store i64 %c, i64* %c.addr, align 8
1182
- ret i32 0
1334
+ %character.addr = alloca i32, align 4
1335
+ store i32 %character, i32* %character.addr, align 4
1336
+ %0 = load i32, i32* %character.addr, align 4
1337
+ ret i32 %0
1183
1338
  }
1184
1339
 
1185
- ; Function Attrs: noinline nounwind ssp uwtable
1186
- define i32 @scandir(i8* noalias noundef %dirp, %struct.dirent*** noalias noundef %namelist, i32 (%struct.dirent*)* noundef %filter, i32 (%struct.dirent**, %struct.dirent**)* noundef %compar) #0 {
1340
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1341
+ define i32 @isalpha(i32 noundef %character) #1 {
1187
1342
  entry:
1188
- %dirp.addr = alloca i8*, align 8
1189
- %namelist.addr = alloca %struct.dirent***, align 8
1190
- %filter.addr = alloca i32 (%struct.dirent*)*, align 8
1191
- %compar.addr = alloca i32 (%struct.dirent**, %struct.dirent**)*, align 8
1192
- store i8* %dirp, i8** %dirp.addr, align 8
1193
- store %struct.dirent*** %namelist, %struct.dirent**** %namelist.addr, align 8
1194
- store i32 (%struct.dirent*)* %filter, i32 (%struct.dirent*)** %filter.addr, align 8
1195
- store i32 (%struct.dirent**, %struct.dirent**)* %compar, i32 (%struct.dirent**, %struct.dirent**)** %compar.addr, align 8
1196
- ret i32 0
1343
+ %character.addr = alloca i32, align 4
1344
+ store i32 %character, i32* %character.addr, align 4
1345
+ %0 = load i32, i32* %character.addr, align 4
1346
+ ret i32 %0
1197
1347
  }
1198
1348
 
1199
- ; Function Attrs: noinline nounwind ssp uwtable
1200
- define i32 @XmbTextPropertyToTextList(i8* noundef %a, i8* noundef %b, i8*** noundef %c, i32* noundef %d) #0 {
1349
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1350
+ define i32 @isblank(i32 noundef %character) #1 {
1201
1351
  entry:
1202
- %a.addr = alloca i8*, align 8
1203
- %b.addr = alloca i8*, align 8
1204
- %c.addr = alloca i8***, align 8
1205
- %d.addr = alloca i32*, align 8
1206
- store i8* %a, i8** %a.addr, align 8
1207
- store i8* %b, i8** %b.addr, align 8
1208
- store i8*** %c, i8**** %c.addr, align 8
1209
- store i32* %d, i32** %d.addr, align 8
1210
- ret i32 0
1352
+ %character.addr = alloca i32, align 4
1353
+ store i32 %character, i32* %character.addr, align 4
1354
+ %0 = load i32, i32* %character.addr, align 4
1355
+ ret i32 %0
1211
1356
  }
1212
1357
 
1213
- ; Function Attrs: noinline nounwind ssp uwtable
1214
- define void @llvm_memcpy_p0i8_p0i8_i64(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
1358
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1359
+ define i32 @iscntrl(i32 noundef %c) #1 {
1215
1360
  entry:
1216
- %dst.addr = alloca i8*, align 8
1217
- %src.addr = alloca i8*, align 8
1218
- %sz.addr = alloca i32, align 4
1219
- %flag.addr = alloca i32, align 4
1220
- store i8* %dst, i8** %dst.addr, align 8
1221
- store i8* %src, i8** %src.addr, align 8
1222
- store i32 %sz, i32* %sz.addr, align 4
1223
- store i32 %flag, i32* %flag.addr, align 4
1224
- ret void
1361
+ %c.addr = alloca i32, align 4
1362
+ store i32 %c, i32* %c.addr, align 4
1363
+ %0 = load i32, i32* %c.addr, align 4
1364
+ ret i32 %0
1225
1365
  }
1226
1366
 
1227
- ; Function Attrs: noinline nounwind ssp uwtable
1228
- define void @llvm_memcpy_p0i8_p0i8_i32(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
1367
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1368
+ define i32 @isdigit(i32 noundef %c) #1 {
1229
1369
  entry:
1230
- %dst.addr = alloca i8*, align 8
1231
- %src.addr = alloca i8*, align 8
1232
- %sz.addr = alloca i32, align 4
1233
- %flag.addr = alloca i32, align 4
1234
- store i8* %dst, i8** %dst.addr, align 8
1235
- store i8* %src, i8** %src.addr, align 8
1236
- store i32 %sz, i32* %sz.addr, align 4
1237
- store i32 %flag, i32* %flag.addr, align 4
1238
- ret void
1370
+ %c.addr = alloca i32, align 4
1371
+ store i32 %c, i32* %c.addr, align 4
1372
+ %0 = load i32, i32* %c.addr, align 4
1373
+ ret i32 %0
1239
1374
  }
1240
1375
 
1241
- ; Function Attrs: noinline nounwind ssp uwtable
1242
- define void @llvm_memcpy(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
1376
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1377
+ define i32 @isgraph(i32 noundef %c) #1 {
1243
1378
  entry:
1244
- %dst.addr = alloca i8*, align 8
1245
- %src.addr = alloca i8*, align 8
1246
- %sz.addr = alloca i32, align 4
1247
- %flag.addr = alloca i32, align 4
1248
- store i8* %dst, i8** %dst.addr, align 8
1249
- store i8* %src, i8** %src.addr, align 8
1250
- store i32 %sz, i32* %sz.addr, align 4
1251
- store i32 %flag, i32* %flag.addr, align 4
1252
- ret void
1379
+ %c.addr = alloca i32, align 4
1380
+ store i32 %c, i32* %c.addr, align 4
1381
+ %0 = load i32, i32* %c.addr, align 4
1382
+ ret i32 %0
1253
1383
  }
1254
1384
 
1255
- ; Function Attrs: noinline nounwind ssp uwtable
1256
- define void @llvm_memmove(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
1385
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1386
+ define i32 @islower(i32 noundef %arg) #1 {
1257
1387
  entry:
1258
- %dst.addr = alloca i8*, align 8
1259
- %src.addr = alloca i8*, align 8
1260
- %sz.addr = alloca i32, align 4
1261
- %flag.addr = alloca i32, align 4
1262
- store i8* %dst, i8** %dst.addr, align 8
1263
- store i8* %src, i8** %src.addr, align 8
1264
- store i32 %sz, i32* %sz.addr, align 4
1265
- store i32 %flag, i32* %flag.addr, align 4
1266
- ret void
1388
+ %arg.addr = alloca i32, align 4
1389
+ store i32 %arg, i32* %arg.addr, align 4
1390
+ %0 = load i32, i32* %arg.addr, align 4
1391
+ ret i32 %0
1267
1392
  }
1268
1393
 
1269
- ; Function Attrs: noinline nounwind ssp uwtable
1270
- define void @llvm_memmove_p0i8_p0i8_i64(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
1394
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1395
+ define i32 @isprint(i32 noundef %c) #1 {
1271
1396
  entry:
1272
- %dst.addr = alloca i8*, align 8
1273
- %src.addr = alloca i8*, align 8
1274
- %sz.addr = alloca i32, align 4
1275
- %flag.addr = alloca i32, align 4
1276
- store i8* %dst, i8** %dst.addr, align 8
1277
- store i8* %src, i8** %src.addr, align 8
1278
- store i32 %sz, i32* %sz.addr, align 4
1279
- store i32 %flag, i32* %flag.addr, align 4
1280
- ret void
1397
+ %c.addr = alloca i32, align 4
1398
+ store i32 %c, i32* %c.addr, align 4
1399
+ %0 = load i32, i32* %c.addr, align 4
1400
+ ret i32 %0
1281
1401
  }
1282
1402
 
1283
- ; Function Attrs: noinline nounwind ssp uwtable
1284
- define void @llvm_memmove_p0i8_p0i8_i32(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
1403
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1404
+ define i32 @ispunct(i32 noundef %argument) #1 {
1285
1405
  entry:
1286
- %dst.addr = alloca i8*, align 8
1287
- %src.addr = alloca i8*, align 8
1288
- %sz.addr = alloca i32, align 4
1289
- %flag.addr = alloca i32, align 4
1290
- store i8* %dst, i8** %dst.addr, align 8
1291
- store i8* %src, i8** %src.addr, align 8
1292
- store i32 %sz, i32* %sz.addr, align 4
1293
- store i32 %flag, i32* %flag.addr, align 4
1294
- ret void
1406
+ %argument.addr = alloca i32, align 4
1407
+ store i32 %argument, i32* %argument.addr, align 4
1408
+ %0 = load i32, i32* %argument.addr, align 4
1409
+ ret i32 %0
1295
1410
  }
1296
1411
 
1297
1412
  ; Function Attrs: noinline nounwind ssp uwtable
1298
- define void @__memcpy_chk(i8* noundef %dst, i8* noundef %src, i32 noundef %sz, i32 noundef %flag) #0 {
1413
+ define i32 @isspace(i8 noundef signext %c) #0 {
1299
1414
  entry:
1300
- %dst.addr = alloca i8*, align 8
1301
- %src.addr = alloca i8*, align 8
1302
- %sz.addr = alloca i32, align 4
1303
- %flag.addr = alloca i32, align 4
1304
- store i8* %dst, i8** %dst.addr, align 8
1305
- store i8* %src, i8** %src.addr, align 8
1306
- store i32 %sz, i32* %sz.addr, align 4
1307
- store i32 %flag, i32* %flag.addr, align 4
1308
- ret void
1415
+ %c.addr = alloca i8, align 1
1416
+ store i8 %c, i8* %c.addr, align 1
1417
+ %0 = load i8, i8* %c.addr, align 1
1418
+ %conv = sext i8 %0 to i32
1419
+ ret i32 %conv
1309
1420
  }
1310
1421
 
1311
- ; Function Attrs: noinline nounwind ssp uwtable
1312
- define i8* @memmove(i8* noundef %str1, i8* noundef %str2, i64 noundef %n) #0 {
1422
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1423
+ define i32 @isupper(i32 noundef %c) #1 {
1313
1424
  entry:
1314
- %str1.addr = alloca i8*, align 8
1315
- %str2.addr = alloca i8*, align 8
1316
- %n.addr = alloca i64, align 8
1317
- store i8* %str1, i8** %str1.addr, align 8
1318
- store i8* %str2, i8** %str2.addr, align 8
1319
- store i64 %n, i64* %n.addr, align 8
1320
- ret i8* null
1425
+ %c.addr = alloca i32, align 4
1426
+ store i32 %c, i32* %c.addr, align 4
1427
+ %0 = load i32, i32* %c.addr, align 4
1428
+ ret i32 %0
1321
1429
  }
1322
1430
 
1323
- ; Function Attrs: noinline nounwind ssp uwtable
1324
- define void @bcopy(i8* noundef %s1, i8* noundef %s2, i64 noundef %n) #0 {
1431
+ ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1432
+ define i32 @isxdigit(i32 noundef %c) #1 {
1325
1433
  entry:
1326
- %s1.addr = alloca i8*, align 8
1327
- %s2.addr = alloca i8*, align 8
1328
- %n.addr = alloca i64, align 8
1329
- store i8* %s1, i8** %s1.addr, align 8
1330
- store i8* %s2, i8** %s2.addr, align 8
1331
- store i64 %n, i64* %n.addr, align 8
1332
- ret void
1434
+ %c.addr = alloca i32, align 4
1435
+ store i32 %c, i32* %c.addr, align 4
1436
+ %0 = load i32, i32* %c.addr, align 4
1437
+ ret i32 %0
1333
1438
  }
1334
1439
 
1335
1440
  ; Function Attrs: noinline nounwind ssp uwtable
1336
- define i8* @memccpy(i8* noalias noundef %dest, i8* noalias noundef %src, i32 noundef %c, i64 noundef %count) #0 {
1441
+ define i8* @asctime_r(i8* noundef %tm, i8* noundef %buf) #0 {
1337
1442
  entry:
1338
- %dest.addr = alloca i8*, align 8
1339
- %src.addr = alloca i8*, align 8
1340
- %c.addr = alloca i32, align 4
1341
- %count.addr = alloca i64, align 8
1342
- store i8* %dest, i8** %dest.addr, align 8
1343
- store i8* %src, i8** %src.addr, align 8
1344
- store i32 %c, i32* %c.addr, align 4
1345
- store i64 %count, i64* %count.addr, align 8
1346
- ret i8* null
1443
+ %tm.addr = alloca i8*, align 8
1444
+ %buf.addr = alloca i8*, align 8
1445
+ store i8* %tm, i8** %tm.addr, align 8
1446
+ store i8* %buf, i8** %buf.addr, align 8
1447
+ %0 = load i8*, i8** %buf.addr, align 8
1448
+ ret i8* %0
1347
1449
  }
1348
1450
 
1349
1451
  ; Function Attrs: noinline nounwind ssp uwtable
1350
- define void @__memmove_chk(i8* noundef %dst, i8* noundef %src, i32 noundef %sz) #0 {
1452
+ define i8* @bsearch(i8* noundef %key, i8* noundef %base, i64 noundef %nitems, i64 noundef %size, i32 (i8*, i8*)* noundef %compar) #0 {
1351
1453
  entry:
1352
- %dst.addr = alloca i8*, align 8
1353
- %src.addr = alloca i8*, align 8
1354
- %sz.addr = alloca i32, align 4
1355
- store i8* %dst, i8** %dst.addr, align 8
1356
- store i8* %src, i8** %src.addr, align 8
1357
- store i32 %sz, i32* %sz.addr, align 4
1358
- ret void
1454
+ %key.addr = alloca i8*, align 8
1455
+ %base.addr = alloca i8*, align 8
1456
+ %nitems.addr = alloca i64, align 8
1457
+ %size.addr = alloca i64, align 8
1458
+ %compar.addr = alloca i32 (i8*, i8*)*, align 8
1459
+ store i8* %key, i8** %key.addr, align 8
1460
+ store i8* %base, i8** %base.addr, align 8
1461
+ store i64 %nitems, i64* %nitems.addr, align 8
1462
+ store i64 %size, i64* %size.addr, align 8
1463
+ store i32 (i8*, i8*)* %compar, i32 (i8*, i8*)** %compar.addr, align 8
1464
+ %0 = load i8*, i8** %base.addr, align 8
1465
+ ret i8* %0
1359
1466
  }
1360
1467
 
1361
1468
  ; Function Attrs: noinline nounwind ssp uwtable
1362
- define void @llvm_memset(i8* noundef %dst, i8 noundef signext %elem, i32 noundef %sz, i32 noundef %flag) #0 {
1469
+ define %struct.mntent* @getmntent_r(i8* noundef %fp, %struct.mntent* noundef %mntbuf, i8* noundef %buf, i32 noundef %buflen) #0 {
1363
1470
  entry:
1364
- %dst.addr = alloca i8*, align 8
1365
- %elem.addr = alloca i8, align 1
1366
- %sz.addr = alloca i32, align 4
1367
- %flag.addr = alloca i32, align 4
1368
- store i8* %dst, i8** %dst.addr, align 8
1369
- store i8 %elem, i8* %elem.addr, align 1
1370
- store i32 %sz, i32* %sz.addr, align 4
1371
- store i32 %flag, i32* %flag.addr, align 4
1372
- ret void
1471
+ %fp.addr = alloca i8*, align 8
1472
+ %mntbuf.addr = alloca %struct.mntent*, align 8
1473
+ %buf.addr = alloca i8*, align 8
1474
+ %buflen.addr = alloca i32, align 4
1475
+ store i8* %fp, i8** %fp.addr, align 8
1476
+ store %struct.mntent* %mntbuf, %struct.mntent** %mntbuf.addr, align 8
1477
+ store i8* %buf, i8** %buf.addr, align 8
1478
+ store i32 %buflen, i32* %buflen.addr, align 4
1479
+ %0 = load %struct.mntent*, %struct.mntent** %mntbuf.addr, align 8
1480
+ ret %struct.mntent* %0
1373
1481
  }
1374
1482
 
1375
1483
  ; Function Attrs: noinline nounwind ssp uwtable
1376
- define void @llvm_memset_p0i8_i32(i8* noundef %dst, i8 noundef signext %elem, i32 noundef %sz, i32 noundef %flag) #0 {
1484
+ define %struct.tm* @gmtime_r(i8* noundef %timer, %struct.tm* noundef %buf) #0 {
1377
1485
  entry:
1378
- %dst.addr = alloca i8*, align 8
1379
- %elem.addr = alloca i8, align 1
1380
- %sz.addr = alloca i32, align 4
1381
- %flag.addr = alloca i32, align 4
1382
- store i8* %dst, i8** %dst.addr, align 8
1383
- store i8 %elem, i8* %elem.addr, align 1
1384
- store i32 %sz, i32* %sz.addr, align 4
1385
- store i32 %flag, i32* %flag.addr, align 4
1386
- ret void
1486
+ %timer.addr = alloca i8*, align 8
1487
+ %buf.addr = alloca %struct.tm*, align 8
1488
+ store i8* %timer, i8** %timer.addr, align 8
1489
+ store %struct.tm* %buf, %struct.tm** %buf.addr, align 8
1490
+ %0 = load %struct.tm*, %struct.tm** %buf.addr, align 8
1491
+ ret %struct.tm* %0
1387
1492
  }
1388
1493
 
1389
1494
  ; Function Attrs: noinline nounwind ssp uwtable
1390
- define void @llvm_memset_p0i8_i64(i8* noundef %dst, i8 noundef signext %elem, i32 noundef %sz, i32 noundef %flag) #0 {
1495
+ define i8* @gzgets(i8* noundef %file, i8* noundef %buf, i32 noundef %len) #0 {
1391
1496
  entry:
1392
- %dst.addr = alloca i8*, align 8
1393
- %elem.addr = alloca i8, align 1
1394
- %sz.addr = alloca i32, align 4
1395
- %flag.addr = alloca i32, align 4
1396
- store i8* %dst, i8** %dst.addr, align 8
1397
- store i8 %elem, i8* %elem.addr, align 1
1398
- store i32 %sz, i32* %sz.addr, align 4
1399
- store i32 %flag, i32* %flag.addr, align 4
1400
- ret void
1497
+ %file.addr = alloca i8*, align 8
1498
+ %buf.addr = alloca i8*, align 8
1499
+ %len.addr = alloca i32, align 4
1500
+ store i8* %file, i8** %file.addr, align 8
1501
+ store i8* %buf, i8** %buf.addr, align 8
1502
+ store i32 %len, i32* %len.addr, align 4
1503
+ %0 = load i8*, i8** %buf.addr, align 8
1504
+ ret i8* %0
1401
1505
  }
1402
1506
 
1403
1507
  ; Function Attrs: noinline nounwind ssp uwtable
1404
- define i8* @__memset_chk(i8* noundef %dest, i32 noundef %c, i64 noundef %destlen, i32 noundef %flag) #0 {
1508
+ define %struct.tm* @localtime_r(i8* noundef %timep, %struct.tm* noundef %result) #0 {
1405
1509
  entry:
1406
- %dest.addr = alloca i8*, align 8
1407
- %c.addr = alloca i32, align 4
1408
- %destlen.addr = alloca i64, align 8
1409
- %flag.addr = alloca i32, align 4
1410
- store i8* %dest, i8** %dest.addr, align 8
1411
- store i32 %c, i32* %c.addr, align 4
1412
- store i64 %destlen, i64* %destlen.addr, align 8
1413
- store i32 %flag, i32* %flag.addr, align 4
1414
- ret i8* null
1510
+ %timep.addr = alloca i8*, align 8
1511
+ %result.addr = alloca %struct.tm*, align 8
1512
+ store i8* %timep, i8** %timep.addr, align 8
1513
+ store %struct.tm* %result, %struct.tm** %result.addr, align 8
1514
+ %0 = load %struct.tm*, %struct.tm** %result.addr, align 8
1515
+ ret %struct.tm* %0
1516
+ }
1517
+
1518
+ ; Function Attrs: noinline nounwind ssp uwtable
1519
+ define i8* @realpath(i8* noalias noundef %path, i8* noalias noundef %resolved_path) #0 {
1520
+ entry:
1521
+ %path.addr = alloca i8*, align 8
1522
+ %resolved_path.addr = alloca i8*, align 8
1523
+ store i8* %path, i8** %path.addr, align 8
1524
+ store i8* %resolved_path, i8** %resolved_path.addr, align 8
1525
+ %0 = load i8*, i8** %resolved_path.addr, align 8
1526
+ ret i8* %0
1415
1527
  }
1416
1528
 
1417
1529
  ; Function Attrs: noinline nounwind ssp uwtable
1418
- define i8* @__strcpy_chk(i8* noundef %dest, i8* noundef %src, i64 noundef %destlen) #0 {
1530
+ define i8* @freopen64(i8* noundef %voidname, i8* noundef %mode, i8* noundef %fp) #0 {
1419
1531
  entry:
1420
- %dest.addr = alloca i8*, align 8
1421
- %src.addr = alloca i8*, align 8
1422
- %destlen.addr = alloca i64, align 8
1423
- store i8* %dest, i8** %dest.addr, align 8
1424
- store i8* %src, i8** %src.addr, align 8
1425
- store i64 %destlen, i64* %destlen.addr, align 8
1426
- ret i8* null
1532
+ %voidname.addr = alloca i8*, align 8
1533
+ %mode.addr = alloca i8*, align 8
1534
+ %fp.addr = alloca i8*, align 8
1535
+ store i8* %voidname, i8** %voidname.addr, align 8
1536
+ store i8* %mode, i8** %mode.addr, align 8
1537
+ store i8* %fp, i8** %fp.addr, align 8
1538
+ %0 = load i8*, i8** %fp.addr, align 8
1539
+ ret i8* %0
1427
1540
  }
1428
1541
 
1429
1542
  ; Function Attrs: noinline nounwind ssp uwtable
1430
- define i8* @__strcat_chk(i8* noundef %dest, i8* noundef %src, i64 noundef %destlen) #0 {
1543
+ define i8* @freopen(i8* noundef %voidname, i8* noundef %mode, i8* noundef %fp) #0 {
1431
1544
  entry:
1432
- %dest.addr = alloca i8*, align 8
1433
- %src.addr = alloca i8*, align 8
1434
- %destlen.addr = alloca i64, align 8
1435
- store i8* %dest, i8** %dest.addr, align 8
1436
- store i8* %src, i8** %src.addr, align 8
1437
- store i64 %destlen, i64* %destlen.addr, align 8
1438
- ret i8* null
1545
+ %voidname.addr = alloca i8*, align 8
1546
+ %mode.addr = alloca i8*, align 8
1547
+ %fp.addr = alloca i8*, align 8
1548
+ store i8* %voidname, i8** %voidname.addr, align 8
1549
+ store i8* %mode, i8** %mode.addr, align 8
1550
+ store i8* %fp, i8** %fp.addr, align 8
1551
+ %0 = load i8*, i8** %fp.addr, align 8
1552
+ ret i8* %0
1439
1553
  }
1440
1554
 
1441
1555
  ; Function Attrs: noinline nounwind ssp uwtable
1442
- define i8* @stpcpy(i8* noalias noundef %dst, i8* noalias noundef %src) #0 {
1556
+ define i8* @inet_ntop(i32 noundef %af, i8* noalias noundef %src, i8* noalias noundef %dst, i32 noundef %size) #0 {
1443
1557
  entry:
1444
- %dst.addr = alloca i8*, align 8
1558
+ %af.addr = alloca i32, align 4
1445
1559
  %src.addr = alloca i8*, align 8
1446
- store i8* %dst, i8** %dst.addr, align 8
1560
+ %dst.addr = alloca i8*, align 8
1561
+ %size.addr = alloca i32, align 4
1562
+ store i32 %af, i32* %af.addr, align 4
1447
1563
  store i8* %src, i8** %src.addr, align 8
1448
- ret i8* null
1564
+ store i8* %dst, i8** %dst.addr, align 8
1565
+ store i32 %size, i32* %size.addr, align 4
1566
+ %0 = load i8*, i8** %dst.addr, align 8
1567
+ ret i8* %0
1449
1568
  }
1450
1569
 
1451
1570
  ; Function Attrs: noinline nounwind ssp uwtable
1452
- define i8* @strcat(i8* noundef %dest, i8* noundef %src) #0 {
1571
+ define double @strtod(i8* noundef %str, i8** noundef %endptr) #0 {
1453
1572
  entry:
1454
- %dest.addr = alloca i8*, align 8
1455
- %src.addr = alloca i8*, align 8
1456
- store i8* %dest, i8** %dest.addr, align 8
1457
- store i8* %src, i8** %src.addr, align 8
1458
- ret i8* null
1573
+ %str.addr = alloca i8*, align 8
1574
+ %endptr.addr = alloca i8**, align 8
1575
+ store i8* %str, i8** %str.addr, align 8
1576
+ store i8** %endptr, i8*** %endptr.addr, align 8
1577
+ %0 = load i8*, i8** %str.addr, align 8
1578
+ %1 = load i8**, i8*** %endptr.addr, align 8
1579
+ store i8* %0, i8** %1, align 8
1580
+ ret double 0.000000e+00
1459
1581
  }
1460
1582
 
1461
1583
  ; Function Attrs: noinline nounwind ssp uwtable
1462
- define i8* @strcpy(i8* noundef %dest, i8* noundef %src) #0 {
1584
+ define float @strtof(i8* noundef %nptr, i8** noundef %endptr) #0 {
1463
1585
  entry:
1464
- %dest.addr = alloca i8*, align 8
1465
- %src.addr = alloca i8*, align 8
1466
- store i8* %dest, i8** %dest.addr, align 8
1467
- store i8* %src, i8** %src.addr, align 8
1468
- ret i8* null
1586
+ %nptr.addr = alloca i8*, align 8
1587
+ %endptr.addr = alloca i8**, align 8
1588
+ store i8* %nptr, i8** %nptr.addr, align 8
1589
+ store i8** %endptr, i8*** %endptr.addr, align 8
1590
+ %0 = load i8*, i8** %nptr.addr, align 8
1591
+ %1 = load i8**, i8*** %endptr.addr, align 8
1592
+ store i8* %0, i8** %1, align 8
1593
+ ret float 0.000000e+00
1469
1594
  }
1470
1595
 
1471
1596
  ; Function Attrs: noinline nounwind ssp uwtable
1472
- define i8* @strncat(i8* noundef %dest, i8* noundef %src, i64 noundef %n) #0 {
1597
+ define i64 @strtol(i8* noundef %str, i8** noundef %endptr, i32 noundef %base) #0 {
1473
1598
  entry:
1474
- %dest.addr = alloca i8*, align 8
1475
- %src.addr = alloca i8*, align 8
1476
- %n.addr = alloca i64, align 8
1477
- store i8* %dest, i8** %dest.addr, align 8
1478
- store i8* %src, i8** %src.addr, align 8
1479
- store i64 %n, i64* %n.addr, align 8
1480
- ret i8* null
1599
+ %str.addr = alloca i8*, align 8
1600
+ %endptr.addr = alloca i8**, align 8
1601
+ %base.addr = alloca i32, align 4
1602
+ store i8* %str, i8** %str.addr, align 8
1603
+ store i8** %endptr, i8*** %endptr.addr, align 8
1604
+ store i32 %base, i32* %base.addr, align 4
1605
+ %0 = load i8*, i8** %str.addr, align 8
1606
+ %1 = load i8**, i8*** %endptr.addr, align 8
1607
+ store i8* %0, i8** %1, align 8
1608
+ ret i64 0
1481
1609
  }
1482
1610
 
1483
1611
  ; Function Attrs: noinline nounwind ssp uwtable
1484
- define i8* @strncpy(i8* noundef %dest, i8* noundef %src, i64 noundef %n) #0 {
1612
+ define x86_fp80 @strtold(i8* noundef %str, i8** noundef %endptr) #0 {
1485
1613
  entry:
1486
- %dest.addr = alloca i8*, align 8
1487
- %src.addr = alloca i8*, align 8
1488
- %n.addr = alloca i64, align 8
1489
- store i8* %dest, i8** %dest.addr, align 8
1490
- store i8* %src, i8** %src.addr, align 8
1491
- store i64 %n, i64* %n.addr, align 8
1492
- ret i8* null
1614
+ %str.addr = alloca i8*, align 8
1615
+ %endptr.addr = alloca i8**, align 8
1616
+ store i8* %str, i8** %str.addr, align 8
1617
+ store i8** %endptr, i8*** %endptr.addr, align 8
1618
+ %0 = load i8*, i8** %str.addr, align 8
1619
+ %1 = load i8**, i8*** %endptr.addr, align 8
1620
+ store i8* %0, i8** %1, align 8
1621
+ ret x86_fp80 0xK00000000000000000000
1493
1622
  }
1494
1623
 
1495
1624
  ; Function Attrs: noinline nounwind ssp uwtable
1496
- define i64 @iconv(i8* noundef %cd, i8** noalias noundef %inbuf, i64* noalias noundef %inbytesleft, i8** noalias noundef %outbuf, i64* noalias noundef %outbytesleft) #0 {
1625
+ define i64 @strtoul(i8* noundef %str, i8** noundef %endptr, i32 noundef %base) #0 {
1497
1626
  entry:
1498
- %cd.addr = alloca i8*, align 8
1499
- %inbuf.addr = alloca i8**, align 8
1500
- %inbytesleft.addr = alloca i64*, align 8
1501
- %outbuf.addr = alloca i8**, align 8
1502
- %outbytesleft.addr = alloca i64*, align 8
1503
- store i8* %cd, i8** %cd.addr, align 8
1504
- store i8** %inbuf, i8*** %inbuf.addr, align 8
1505
- store i64* %inbytesleft, i64** %inbytesleft.addr, align 8
1506
- store i8** %outbuf, i8*** %outbuf.addr, align 8
1507
- store i64* %outbytesleft, i64** %outbytesleft.addr, align 8
1627
+ %str.addr = alloca i8*, align 8
1628
+ %endptr.addr = alloca i8**, align 8
1629
+ %base.addr = alloca i32, align 4
1630
+ store i8* %str, i8** %str.addr, align 8
1631
+ store i8** %endptr, i8*** %endptr.addr, align 8
1632
+ store i32 %base, i32* %base.addr, align 4
1633
+ %0 = load i8*, i8** %str.addr, align 8
1634
+ %1 = load i8**, i8*** %endptr.addr, align 8
1635
+ store i8* %0, i8** %1, align 8
1508
1636
  ret i64 0
1509
1637
  }
1510
1638
 
1511
1639
  ; Function Attrs: noinline nounwind ssp uwtable
1512
- define i8* @_ZNSt5arrayIPK1ALm2EE4backEv(i8* noundef %arg) #0 {
1640
+ define i32 @readdir_r(i8* noundef %__restrict__dir, i8* noundef %__restrict__entry, i8** noundef %__restrict__result) #0 {
1513
1641
  entry:
1514
- %arg.addr = alloca i8*, align 8
1515
- %ptr1 = alloca i8*, align 8
1516
- %ptr2 = alloca i8*, align 8
1517
- store i8* %arg, i8** %arg.addr, align 8
1518
- %0 = load i8*, i8** %arg.addr, align 8
1519
- %add.ptr = getelementptr inbounds i8, i8* %0, i64 0
1520
- store i8* %add.ptr, i8** %ptr1, align 8
1521
- %1 = load i8*, i8** %ptr1, align 8
1522
- %add.ptr1 = getelementptr inbounds i8, i8* %1, i64 0
1523
- store i8* %add.ptr1, i8** %ptr2, align 8
1524
- %2 = load i8*, i8** %ptr2, align 8
1525
- ret i8* %2
1642
+ %__restrict__dir.addr = alloca i8*, align 8
1643
+ %__restrict__entry.addr = alloca i8*, align 8
1644
+ %__restrict__result.addr = alloca i8**, align 8
1645
+ store i8* %__restrict__dir, i8** %__restrict__dir.addr, align 8
1646
+ store i8* %__restrict__entry, i8** %__restrict__entry.addr, align 8
1647
+ store i8** %__restrict__result, i8*** %__restrict__result.addr, align 8
1648
+ %0 = load i8**, i8*** %__restrict__result.addr, align 8
1649
+ %1 = load i8*, i8** %0, align 8
1650
+ store i8* %1, i8** %__restrict__entry.addr, align 8
1651
+ ret i32 0
1526
1652
  }
1527
1653
 
1528
1654
  ; Function Attrs: noinline nounwind ssp uwtable
1529
- define i8* @__rawmemchr(i8* noundef %s, i32 noundef %c) #0 {
1655
+ define i32 @getpwnam_r(i8* noundef %name, i8* noundef %pwd, i8* noundef %buf, i64 noundef %buflen, i8** noundef %result) #0 {
1530
1656
  entry:
1531
- %s.addr = alloca i8*, align 8
1532
- %c.addr = alloca i32, align 4
1533
- store i8* %s, i8** %s.addr, align 8
1534
- store i32 %c, i32* %c.addr, align 4
1535
- %0 = load i8*, i8** %s.addr, align 8
1536
- ret i8* %0
1657
+ %name.addr = alloca i8*, align 8
1658
+ %pwd.addr = alloca i8*, align 8
1659
+ %buf.addr = alloca i8*, align 8
1660
+ %buflen.addr = alloca i64, align 8
1661
+ %result.addr = alloca i8**, align 8
1662
+ store i8* %name, i8** %name.addr, align 8
1663
+ store i8* %pwd, i8** %pwd.addr, align 8
1664
+ store i8* %buf, i8** %buf.addr, align 8
1665
+ store i64 %buflen, i64* %buflen.addr, align 8
1666
+ store i8** %result, i8*** %result.addr, align 8
1667
+ %0 = load i8*, i8** %pwd.addr, align 8
1668
+ %1 = load i8**, i8*** %result.addr, align 8
1669
+ store i8* %0, i8** %1, align 8
1670
+ ret i32 0
1537
1671
  }
1538
1672
 
1539
1673
  ; Function Attrs: noinline nounwind ssp uwtable
1540
- define %struct.jpeg_error_mgr* @jpeg_std_error(%struct.jpeg_error_mgr* noundef %a) #0 {
1674
+ define i32 @getpwuid_r(i32 noundef %uid, i8* noundef %pwd, i8* noundef %buf, i64 noundef %buflen, i8** noundef %result) #0 {
1541
1675
  entry:
1542
- %a.addr = alloca %struct.jpeg_error_mgr*, align 8
1543
- store %struct.jpeg_error_mgr* %a, %struct.jpeg_error_mgr** %a.addr, align 8
1544
- %0 = load %struct.jpeg_error_mgr*, %struct.jpeg_error_mgr** %a.addr, align 8
1545
- ret %struct.jpeg_error_mgr* %0
1676
+ %uid.addr = alloca i32, align 4
1677
+ %pwd.addr = alloca i8*, align 8
1678
+ %buf.addr = alloca i8*, align 8
1679
+ %buflen.addr = alloca i64, align 8
1680
+ %result.addr = alloca i8**, align 8
1681
+ store i32 %uid, i32* %uid.addr, align 4
1682
+ store i8* %pwd, i8** %pwd.addr, align 8
1683
+ store i8* %buf, i8** %buf.addr, align 8
1684
+ store i64 %buflen, i64* %buflen.addr, align 8
1685
+ store i8** %result, i8*** %result.addr, align 8
1686
+ %0 = load i8*, i8** %pwd.addr, align 8
1687
+ %1 = load i8**, i8*** %result.addr, align 8
1688
+ store i8* %0, i8** %1, align 8
1689
+ ret i32 0
1546
1690
  }
1547
1691
 
1548
1692
  ; Function Attrs: noinline nounwind ssp uwtable
1549
- define i8* @fgets(i8* noundef %str, i32 noundef %n, i8* noundef %stream) #0 {
1693
+ define void @_ZNSt8__detail15_List_node_base7_M_hookEPS0_(i8* noundef %arg0, i8** noundef %arg1) #0 {
1550
1694
  entry:
1551
- %str.addr = alloca i8*, align 8
1552
- %n.addr = alloca i32, align 4
1553
- %stream.addr = alloca i8*, align 8
1554
- store i8* %str, i8** %str.addr, align 8
1555
- store i32 %n, i32* %n.addr, align 4
1556
- store i8* %stream, i8** %stream.addr, align 8
1557
- %0 = load i8*, i8** %str.addr, align 8
1558
- ret i8* %0
1695
+ %arg0.addr = alloca i8*, align 8
1696
+ %arg1.addr = alloca i8**, align 8
1697
+ store i8* %arg0, i8** %arg0.addr, align 8
1698
+ store i8** %arg1, i8*** %arg1.addr, align 8
1699
+ %0 = load i8*, i8** %arg0.addr, align 8
1700
+ %1 = load i8**, i8*** %arg1.addr, align 8
1701
+ store i8* %0, i8** %1, align 8
1702
+ ret void
1559
1703
  }
1560
1704
 
1561
1705
  ; Function Attrs: noinline nounwind ssp uwtable
1562
- define i8* @memchr(i8* noundef %str, i32 noundef %c, i64 noundef %n) #0 {
1706
+ define i8* @__dynamic_cast(i8* noundef %source, i8* noundef %sourceTypeInfo, i8* noundef %targetTypeInfo, i64 noundef %castType) #0 {
1563
1707
  entry:
1564
- %str.addr = alloca i8*, align 8
1565
- %c.addr = alloca i32, align 4
1566
- %n.addr = alloca i64, align 8
1567
- store i8* %str, i8** %str.addr, align 8
1568
- store i32 %c, i32* %c.addr, align 4
1569
- store i64 %n, i64* %n.addr, align 8
1570
- %0 = load i8*, i8** %str.addr, align 8
1708
+ %source.addr = alloca i8*, align 8
1709
+ %sourceTypeInfo.addr = alloca i8*, align 8
1710
+ %targetTypeInfo.addr = alloca i8*, align 8
1711
+ %castType.addr = alloca i64, align 8
1712
+ store i8* %source, i8** %source.addr, align 8
1713
+ store i8* %sourceTypeInfo, i8** %sourceTypeInfo.addr, align 8
1714
+ store i8* %targetTypeInfo, i8** %targetTypeInfo.addr, align 8
1715
+ store i64 %castType, i64* %castType.addr, align 8
1716
+ %0 = load i8*, i8** %source.addr, align 8
1571
1717
  ret i8* %0
1572
1718
  }
1573
1719
 
1574
1720
  ; Function Attrs: noinline nounwind ssp uwtable
1575
- define i8* @mremap(i8* noundef %old_address, i64 noundef %old_size, i64 noundef %new_size, i32 noundef %flags) #0 {
1576
- entry:
1577
- %old_address.addr = alloca i8*, align 8
1578
- %old_size.addr = alloca i64, align 8
1579
- %new_size.addr = alloca i64, align 8
1580
- %flags.addr = alloca i32, align 4
1581
- store i8* %old_address, i8** %old_address.addr, align 8
1582
- store i64 %old_size, i64* %old_size.addr, align 8
1583
- store i64 %new_size, i64* %new_size.addr, align 8
1584
- store i32 %flags, i32* %flags.addr, align 4
1585
- %0 = load i8*, i8** %old_address.addr, align 8
1586
- ret i8* %0
1721
+ define void @_ZNSsC1EPKcRKSaIcE(i8** noundef %arg0, i8* noundef %arg1) #0 {
1722
+ entry:
1723
+ %arg0.addr = alloca i8**, align 8
1724
+ %arg1.addr = alloca i8*, align 8
1725
+ store i8** %arg0, i8*** %arg0.addr, align 8
1726
+ store i8* %arg1, i8** %arg1.addr, align 8
1727
+ %0 = load i8*, i8** %arg1.addr, align 8
1728
+ %1 = load i8**, i8*** %arg0.addr, align 8
1729
+ store i8* %0, i8** %1, align 8
1730
+ ret void
1587
1731
  }
1588
1732
 
1589
1733
  ; Function Attrs: noinline nounwind ssp uwtable
1590
- define i8* @strchr(i8* noundef %str, i32 noundef %c) #0 {
1734
+ define void @_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_(i8** noundef %arg0, i8* noundef %arg1) #0 {
1591
1735
  entry:
1592
- %str.addr = alloca i8*, align 8
1593
- %c.addr = alloca i32, align 4
1594
- store i8* %str, i8** %str.addr, align 8
1595
- store i32 %c, i32* %c.addr, align 4
1596
- %0 = load i8*, i8** %str.addr, align 8
1597
- ret i8* %0
1736
+ %arg0.addr = alloca i8**, align 8
1737
+ %arg1.addr = alloca i8*, align 8
1738
+ store i8** %arg0, i8*** %arg0.addr, align 8
1739
+ store i8* %arg1, i8** %arg1.addr, align 8
1740
+ %0 = load i8*, i8** %arg1.addr, align 8
1741
+ %1 = load i8**, i8*** %arg0.addr, align 8
1742
+ store i8* %0, i8** %1, align 8
1743
+ ret void
1598
1744
  }
1599
1745
 
1600
1746
  ; Function Attrs: noinline nounwind ssp uwtable
1601
- define i8* @strerror_r(i32 noundef %errnum, i8* noundef %buf, i64 noundef %buflen) #0 {
1747
+ define i16** @__ctype_b_loc() #0 {
1602
1748
  entry:
1603
- %errnum.addr = alloca i32, align 4
1604
- %buf.addr = alloca i8*, align 8
1605
- %buflen.addr = alloca i64, align 8
1606
- store i32 %errnum, i32* %errnum.addr, align 4
1607
- store i8* %buf, i8** %buf.addr, align 8
1608
- store i64 %buflen, i64* %buflen.addr, align 8
1609
- %0 = load i8*, i8** %buf.addr, align 8
1610
- ret i8* %0
1749
+ %call = call i8* @malloc(i64 noundef 10)
1750
+ %0 = bitcast i8* %call to i16**
1751
+ ret i16** %0
1611
1752
  }
1612
1753
 
1613
1754
  ; Function Attrs: noinline nounwind ssp uwtable
1614
- define i8* @strpbrk(i8* noundef %str1, i8* noundef %str2) #0 {
1755
+ define i32** @__ctype_tolower_loc() #0 {
1615
1756
  entry:
1616
- %str1.addr = alloca i8*, align 8
1617
- %str2.addr = alloca i8*, align 8
1618
- store i8* %str1, i8** %str1.addr, align 8
1619
- store i8* %str2, i8** %str2.addr, align 8
1620
- %0 = load i8*, i8** %str1.addr, align 8
1621
- ret i8* %0
1757
+ %call = call i8* @malloc(i64 noundef 10)
1758
+ %0 = bitcast i8* %call to i32**
1759
+ ret i32** %0
1622
1760
  }
1623
1761
 
1624
1762
  ; Function Attrs: noinline nounwind ssp uwtable
1625
- define i8* @strptime(i8* noundef %s, i8* noundef %format, i8* noundef %tm) #0 {
1763
+ define i32** @__ctype_toupper_loc() #0 {
1626
1764
  entry:
1627
- %s.addr = alloca i8*, align 8
1628
- %format.addr = alloca i8*, align 8
1629
- %tm.addr = alloca i8*, align 8
1630
- store i8* %s, i8** %s.addr, align 8
1631
- store i8* %format, i8** %format.addr, align 8
1632
- store i8* %tm, i8** %tm.addr, align 8
1633
- %0 = load i8*, i8** %s.addr, align 8
1634
- ret i8* %0
1765
+ %call = call i8* @malloc(i64 noundef 10)
1766
+ %0 = bitcast i8* %call to i32**
1767
+ ret i32** %0
1635
1768
  }
1636
1769
 
1637
1770
  ; Function Attrs: noinline nounwind ssp uwtable
1638
- define i8* @strrchr(i8* noundef %str, i32 noundef %c) #0 {
1771
+ define i32* @__errno_location() #0 {
1639
1772
  entry:
1640
- %str.addr = alloca i8*, align 8
1641
- %c.addr = alloca i32, align 4
1642
- store i8* %str, i8** %str.addr, align 8
1643
- store i32 %c, i32* %c.addr, align 4
1644
- %0 = load i8*, i8** %str.addr, align 8
1645
- ret i8* %0
1773
+ %call = call i8* @malloc(i64 noundef 10)
1774
+ %0 = bitcast i8* %call to i32*
1775
+ ret i32* %0
1646
1776
  }
1647
1777
 
1648
1778
  ; Function Attrs: noinline nounwind ssp uwtable
1649
- define i8* @strstr(i8* noundef %haystack, i8* noundef %needle) #0 {
1779
+ define i32* @__h_errno_location() #0 {
1650
1780
  entry:
1651
- %haystack.addr = alloca i8*, align 8
1652
- %needle.addr = alloca i8*, align 8
1653
- store i8* %haystack, i8** %haystack.addr, align 8
1654
- store i8* %needle, i8** %needle.addr, align 8
1655
- %0 = load i8*, i8** %haystack.addr, align 8
1656
- ret i8* %0
1781
+ %call = call i8* @malloc(i64 noundef 10)
1782
+ %0 = bitcast i8* %call to i32*
1783
+ ret i32* %0
1657
1784
  }
1658
1785
 
1659
1786
  ; Function Attrs: noinline nounwind ssp uwtable
1660
- define i8* @tmpnam_r(i8* noundef %s) #0 {
1787
+ define i8* @__res_state() #0 {
1661
1788
  entry:
1662
- %s.addr = alloca i8*, align 8
1663
- store i8* %s, i8** %s.addr, align 8
1664
- %0 = load i8*, i8** %s.addr, align 8
1665
- ret i8* %0
1789
+ %call = call i8* @malloc(i64 noundef 10)
1790
+ ret i8* %call
1666
1791
  }
1667
1792
 
1668
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1669
- define i32 @isalnum(i32 noundef %character) #1 {
1793
+ ; Function Attrs: noinline nounwind ssp uwtable
1794
+ define i8* @asctime(i8* noundef %timeptr) #0 {
1670
1795
  entry:
1671
- %character.addr = alloca i32, align 4
1672
- store i32 %character, i32* %character.addr, align 4
1673
- %0 = load i32, i32* %character.addr, align 4
1674
- ret i32 %0
1796
+ %timeptr.addr = alloca i8*, align 8
1797
+ store i8* %timeptr, i8** %timeptr.addr, align 8
1798
+ %call = call i8* @malloc(i64 noundef 10)
1799
+ ret i8* %call
1675
1800
  }
1676
1801
 
1677
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1678
- define i32 @isalpha(i32 noundef %character) #1 {
1802
+ ; Function Attrs: noinline nounwind ssp uwtable
1803
+ define i8* @bindtextdomain(i8* noundef %domainname, i8* noundef %dirname) #0 {
1679
1804
  entry:
1680
- %character.addr = alloca i32, align 4
1681
- store i32 %character, i32* %character.addr, align 4
1682
- %0 = load i32, i32* %character.addr, align 4
1683
- ret i32 %0
1805
+ %domainname.addr = alloca i8*, align 8
1806
+ %dirname.addr = alloca i8*, align 8
1807
+ store i8* %domainname, i8** %domainname.addr, align 8
1808
+ store i8* %dirname, i8** %dirname.addr, align 8
1809
+ %call = call i8* @malloc(i64 noundef 10)
1810
+ ret i8* %call
1684
1811
  }
1685
1812
 
1686
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1687
- define i32 @isblank(i32 noundef %character) #1 {
1813
+ ; Function Attrs: noinline nounwind ssp uwtable
1814
+ define i8* @bind_textdomain_codeset(i8* noundef %domainname, i8* noundef %codeset) #0 {
1688
1815
  entry:
1689
- %character.addr = alloca i32, align 4
1690
- store i32 %character, i32* %character.addr, align 4
1691
- %0 = load i32, i32* %character.addr, align 4
1692
- ret i32 %0
1816
+ %domainname.addr = alloca i8*, align 8
1817
+ %codeset.addr = alloca i8*, align 8
1818
+ store i8* %domainname, i8** %domainname.addr, align 8
1819
+ store i8* %codeset, i8** %codeset.addr, align 8
1820
+ %call = call i8* @malloc(i64 noundef 10)
1821
+ ret i8* %call
1693
1822
  }
1694
1823
 
1695
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1696
- define i32 @iscntrl(i32 noundef %c) #1 {
1824
+ ; Function Attrs: noinline nounwind ssp uwtable
1825
+ define i8* @ctermid(i8* noundef %s) #0 {
1697
1826
  entry:
1698
- %c.addr = alloca i32, align 4
1699
- store i32 %c, i32* %c.addr, align 4
1700
- %0 = load i32, i32* %c.addr, align 4
1701
- ret i32 %0
1827
+ %s.addr = alloca i8*, align 8
1828
+ store i8* %s, i8** %s.addr, align 8
1829
+ %call = call i8* @malloc(i64 noundef 10)
1830
+ ret i8* %call
1702
1831
  }
1703
1832
 
1704
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1705
- define i32 @isdigit(i32 noundef %c) #1 {
1833
+ ; Function Attrs: noinline nounwind ssp uwtable
1834
+ define i8* @dcgettext(i8* noundef %domainname, i8* noundef %msgid, i32 noundef %category) #0 {
1706
1835
  entry:
1707
- %c.addr = alloca i32, align 4
1708
- store i32 %c, i32* %c.addr, align 4
1709
- %0 = load i32, i32* %c.addr, align 4
1710
- ret i32 %0
1836
+ %domainname.addr = alloca i8*, align 8
1837
+ %msgid.addr = alloca i8*, align 8
1838
+ %category.addr = alloca i32, align 4
1839
+ store i8* %domainname, i8** %domainname.addr, align 8
1840
+ store i8* %msgid, i8** %msgid.addr, align 8
1841
+ store i32 %category, i32* %category.addr, align 4
1842
+ %call = call i8* @malloc(i64 noundef 10)
1843
+ ret i8* %call
1711
1844
  }
1712
1845
 
1713
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1714
- define i32 @isgraph(i32 noundef %c) #1 {
1846
+ ; Function Attrs: noinline nounwind ssp uwtable
1847
+ define i8* @dgettext(i8* noundef %domainname, i8* noundef %msgid) #0 {
1715
1848
  entry:
1716
- %c.addr = alloca i32, align 4
1717
- store i32 %c, i32* %c.addr, align 4
1718
- %0 = load i32, i32* %c.addr, align 4
1719
- ret i32 %0
1849
+ %domainname.addr = alloca i8*, align 8
1850
+ %msgid.addr = alloca i8*, align 8
1851
+ store i8* %domainname, i8** %domainname.addr, align 8
1852
+ store i8* %msgid, i8** %msgid.addr, align 8
1853
+ %call = call i8* @malloc(i64 noundef 10)
1854
+ ret i8* %call
1720
1855
  }
1721
1856
 
1722
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1723
- define i32 @islower(i32 noundef %arg) #1 {
1857
+ ; Function Attrs: noinline nounwind ssp uwtable
1858
+ define i8* @dngettext(i8* noundef %domainname, i8* noundef %msgid, i8* noundef %msgid_plural, i64 noundef %n) #0 {
1724
1859
  entry:
1725
- %arg.addr = alloca i32, align 4
1726
- store i32 %arg, i32* %arg.addr, align 4
1727
- %0 = load i32, i32* %arg.addr, align 4
1728
- ret i32 %0
1860
+ %domainname.addr = alloca i8*, align 8
1861
+ %msgid.addr = alloca i8*, align 8
1862
+ %msgid_plural.addr = alloca i8*, align 8
1863
+ %n.addr = alloca i64, align 8
1864
+ store i8* %domainname, i8** %domainname.addr, align 8
1865
+ store i8* %msgid, i8** %msgid.addr, align 8
1866
+ store i8* %msgid_plural, i8** %msgid_plural.addr, align 8
1867
+ store i64 %n, i64* %n.addr, align 8
1868
+ %call = call i8* @malloc(i64 noundef 10)
1869
+ ret i8* %call
1729
1870
  }
1730
1871
 
1731
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1732
- define i32 @isprint(i32 noundef %c) #1 {
1872
+ ; Function Attrs: noinline nounwind ssp uwtable
1873
+ define %struct.group* @getgrgid(i32 noundef %gid) #0 {
1733
1874
  entry:
1734
- %c.addr = alloca i32, align 4
1735
- store i32 %c, i32* %c.addr, align 4
1736
- %0 = load i32, i32* %c.addr, align 4
1737
- ret i32 %0
1875
+ %gid.addr = alloca i32, align 4
1876
+ store i32 %gid, i32* %gid.addr, align 4
1877
+ %call = call i8* @malloc(i64 noundef 10)
1878
+ %0 = bitcast i8* %call to %struct.group*
1879
+ ret %struct.group* %0
1738
1880
  }
1739
1881
 
1740
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1741
- define i32 @ispunct(i32 noundef %argument) #1 {
1882
+ ; Function Attrs: noinline nounwind ssp uwtable
1883
+ define %struct.group* @getgrnam(i8* noundef %name) #0 {
1742
1884
  entry:
1743
- %argument.addr = alloca i32, align 4
1744
- store i32 %argument, i32* %argument.addr, align 4
1745
- %0 = load i32, i32* %argument.addr, align 4
1746
- ret i32 %0
1885
+ %name.addr = alloca i8*, align 8
1886
+ store i8* %name, i8** %name.addr, align 8
1887
+ %call = call i8* @malloc(i64 noundef 10)
1888
+ %0 = bitcast i8* %call to %struct.group*
1889
+ ret %struct.group* %0
1747
1890
  }
1748
1891
 
1749
1892
  ; Function Attrs: noinline nounwind ssp uwtable
1750
- define i32 @isspace(i8 noundef signext %c) #0 {
1893
+ define %struct.hostent* @gethostbyaddr(i8* noundef %addr, i32 noundef %len, i32 noundef %type) #0 {
1751
1894
  entry:
1752
- %c.addr = alloca i8, align 1
1753
- store i8 %c, i8* %c.addr, align 1
1754
- %0 = load i8, i8* %c.addr, align 1
1755
- %conv = sext i8 %0 to i32
1756
- ret i32 %conv
1895
+ %addr.addr = alloca i8*, align 8
1896
+ %len.addr = alloca i32, align 4
1897
+ %type.addr = alloca i32, align 4
1898
+ store i8* %addr, i8** %addr.addr, align 8
1899
+ store i32 %len, i32* %len.addr, align 4
1900
+ store i32 %type, i32* %type.addr, align 4
1901
+ %call = call i8* @malloc(i64 noundef 10)
1902
+ %0 = bitcast i8* %call to %struct.hostent*
1903
+ ret %struct.hostent* %0
1757
1904
  }
1758
1905
 
1759
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1760
- define i32 @isupper(i32 noundef %c) #1 {
1906
+ ; Function Attrs: noinline nounwind ssp uwtable
1907
+ define %struct.hostent* @gethostbyname(i8* noundef %name) #0 {
1761
1908
  entry:
1762
- %c.addr = alloca i32, align 4
1763
- store i32 %c, i32* %c.addr, align 4
1764
- %0 = load i32, i32* %c.addr, align 4
1765
- ret i32 %0
1909
+ %name.addr = alloca i8*, align 8
1910
+ store i8* %name, i8** %name.addr, align 8
1911
+ %call = call i8* @malloc(i64 noundef 10)
1912
+ %0 = bitcast i8* %call to %struct.hostent*
1913
+ ret %struct.hostent* %0
1766
1914
  }
1767
1915
 
1768
- ; Function Attrs: noinline nounwind readonly ssp uwtable willreturn
1769
- define i32 @isxdigit(i32 noundef %c) #1 {
1916
+ ; Function Attrs: noinline nounwind ssp uwtable
1917
+ define %struct.hostent* @gethostbyname2(i8* noundef %name, i32 noundef %af) #0 {
1770
1918
  entry:
1771
- %c.addr = alloca i32, align 4
1772
- store i32 %c, i32* %c.addr, align 4
1773
- %0 = load i32, i32* %c.addr, align 4
1774
- ret i32 %0
1919
+ %name.addr = alloca i8*, align 8
1920
+ %af.addr = alloca i32, align 4
1921
+ store i8* %name, i8** %name.addr, align 8
1922
+ store i32 %af, i32* %af.addr, align 4
1923
+ %call = call i8* @malloc(i64 noundef 10)
1924
+ %0 = bitcast i8* %call to %struct.hostent*
1925
+ ret %struct.hostent* %0
1775
1926
  }
1776
1927
 
1777
1928
  ; Function Attrs: noinline nounwind ssp uwtable
1778
- define i8* @asctime_r(i8* noundef %tm, i8* noundef %buf) #0 {
1929
+ define %struct.mntent* @getmntent(i8* noundef %stream) #0 {
1779
1930
  entry:
1780
- %tm.addr = alloca i8*, align 8
1781
- %buf.addr = alloca i8*, align 8
1782
- store i8* %tm, i8** %tm.addr, align 8
1783
- store i8* %buf, i8** %buf.addr, align 8
1784
- %0 = load i8*, i8** %buf.addr, align 8
1785
- ret i8* %0
1931
+ %stream.addr = alloca i8*, align 8
1932
+ store i8* %stream, i8** %stream.addr, align 8
1933
+ %call = call i8* @malloc(i64 noundef 10)
1934
+ %0 = bitcast i8* %call to %struct.mntent*
1935
+ ret %struct.mntent* %0
1786
1936
  }
1787
1937
 
1788
1938
  ; Function Attrs: noinline nounwind ssp uwtable
1789
- define i8* @bsearch(i8* noundef %key, i8* noundef %base, i64 noundef %nitems, i64 noundef %size, i32 (i8*, i8*)* noundef %compar) #0 {
1939
+ define %struct.protoent* @getprotobyname(i8* noundef %name) #0 {
1790
1940
  entry:
1791
- %key.addr = alloca i8*, align 8
1792
- %base.addr = alloca i8*, align 8
1793
- %nitems.addr = alloca i64, align 8
1794
- %size.addr = alloca i64, align 8
1795
- %compar.addr = alloca i32 (i8*, i8*)*, align 8
1796
- store i8* %key, i8** %key.addr, align 8
1797
- store i8* %base, i8** %base.addr, align 8
1798
- store i64 %nitems, i64* %nitems.addr, align 8
1799
- store i64 %size, i64* %size.addr, align 8
1800
- store i32 (i8*, i8*)* %compar, i32 (i8*, i8*)** %compar.addr, align 8
1801
- %0 = load i8*, i8** %base.addr, align 8
1802
- ret i8* %0
1941
+ %name.addr = alloca i8*, align 8
1942
+ store i8* %name, i8** %name.addr, align 8
1943
+ %call = call i8* @malloc(i64 noundef 10)
1944
+ %0 = bitcast i8* %call to %struct.protoent*
1945
+ ret %struct.protoent* %0
1803
1946
  }
1804
1947
 
1805
1948
  ; Function Attrs: noinline nounwind ssp uwtable
1806
- define %struct.mntent* @getmntent_r(i8* noundef %fp, %struct.mntent* noundef %mntbuf, i8* noundef %buf, i32 noundef %buflen) #0 {
1807
- entry:
1808
- %fp.addr = alloca i8*, align 8
1809
- %mntbuf.addr = alloca %struct.mntent*, align 8
1810
- %buf.addr = alloca i8*, align 8
1811
- %buflen.addr = alloca i32, align 4
1812
- store i8* %fp, i8** %fp.addr, align 8
1813
- store %struct.mntent* %mntbuf, %struct.mntent** %mntbuf.addr, align 8
1814
- store i8* %buf, i8** %buf.addr, align 8
1815
- store i32 %buflen, i32* %buflen.addr, align 4
1816
- %0 = load %struct.mntent*, %struct.mntent** %mntbuf.addr, align 8
1817
- ret %struct.mntent* %0
1949
+ define %struct.protoent* @getprotobynumber(i32 noundef %proto) #0 {
1950
+ entry:
1951
+ %proto.addr = alloca i32, align 4
1952
+ store i32 %proto, i32* %proto.addr, align 4
1953
+ %call = call i8* @malloc(i64 noundef 10)
1954
+ %0 = bitcast i8* %call to %struct.protoent*
1955
+ ret %struct.protoent* %0
1818
1956
  }
1819
1957
 
1820
1958
  ; Function Attrs: noinline nounwind ssp uwtable
1821
- define %struct.tm* @gmtime_r(i8* noundef %timer, %struct.tm* noundef %buf) #0 {
1959
+ define %struct.passwd* @getpwent() #0 {
1822
1960
  entry:
1823
- %timer.addr = alloca i8*, align 8
1824
- %buf.addr = alloca %struct.tm*, align 8
1825
- store i8* %timer, i8** %timer.addr, align 8
1826
- store %struct.tm* %buf, %struct.tm** %buf.addr, align 8
1827
- %0 = load %struct.tm*, %struct.tm** %buf.addr, align 8
1828
- ret %struct.tm* %0
1961
+ %call = call i8* @malloc(i64 noundef 10)
1962
+ %0 = bitcast i8* %call to %struct.passwd*
1963
+ ret %struct.passwd* %0
1829
1964
  }
1830
1965
 
1831
1966
  ; Function Attrs: noinline nounwind ssp uwtable
1832
- define i8* @gzgets(i8* noundef %file, i8* noundef %buf, i32 noundef %len) #0 {
1967
+ define %struct.passwd* @getpwnam(i8* noundef %name) #0 {
1833
1968
  entry:
1834
- %file.addr = alloca i8*, align 8
1835
- %buf.addr = alloca i8*, align 8
1836
- %len.addr = alloca i32, align 4
1837
- store i8* %file, i8** %file.addr, align 8
1838
- store i8* %buf, i8** %buf.addr, align 8
1839
- store i32 %len, i32* %len.addr, align 4
1840
- %0 = load i8*, i8** %buf.addr, align 8
1841
- ret i8* %0
1969
+ %name.addr = alloca i8*, align 8
1970
+ store i8* %name, i8** %name.addr, align 8
1971
+ %call = call i8* @malloc(i64 noundef 10)
1972
+ %0 = bitcast i8* %call to %struct.passwd*
1973
+ ret %struct.passwd* %0
1842
1974
  }
1843
1975
 
1844
1976
  ; Function Attrs: noinline nounwind ssp uwtable
1845
- define %struct.tm* @localtime_r(i8* noundef %timep, %struct.tm* noundef %result) #0 {
1977
+ define %struct.passwd* @getpwuid(i32 noundef %uid) #0 {
1846
1978
  entry:
1847
- %timep.addr = alloca i8*, align 8
1848
- %result.addr = alloca %struct.tm*, align 8
1849
- store i8* %timep, i8** %timep.addr, align 8
1850
- store %struct.tm* %result, %struct.tm** %result.addr, align 8
1851
- %0 = load %struct.tm*, %struct.tm** %result.addr, align 8
1852
- ret %struct.tm* %0
1979
+ %uid.addr = alloca i32, align 4
1980
+ store i32 %uid, i32* %uid.addr, align 4
1981
+ %call = call i8* @malloc(i64 noundef 10)
1982
+ %0 = bitcast i8* %call to %struct.passwd*
1983
+ ret %struct.passwd* %0
1853
1984
  }
1854
1985
 
1855
1986
  ; Function Attrs: noinline nounwind ssp uwtable
1856
- define i8* @realpath(i8* noalias noundef %path, i8* noalias noundef %resolved_path) #0 {
1987
+ define %struct.servent* @getservbyname(i8* noundef %name, i8* noundef %proto) #0 {
1857
1988
  entry:
1858
- %path.addr = alloca i8*, align 8
1859
- %resolved_path.addr = alloca i8*, align 8
1860
- store i8* %path, i8** %path.addr, align 8
1861
- store i8* %resolved_path, i8** %resolved_path.addr, align 8
1862
- %0 = load i8*, i8** %resolved_path.addr, align 8
1863
- ret i8* %0
1989
+ %name.addr = alloca i8*, align 8
1990
+ %proto.addr = alloca i8*, align 8
1991
+ store i8* %name, i8** %name.addr, align 8
1992
+ store i8* %proto, i8** %proto.addr, align 8
1993
+ %call = call i8* @malloc(i64 noundef 10)
1994
+ %0 = bitcast i8* %call to %struct.servent*
1995
+ ret %struct.servent* %0
1864
1996
  }
1865
1997
 
1866
1998
  ; Function Attrs: noinline nounwind ssp uwtable
1867
- define i8* @freopen64(i8* noundef %voidname, i8* noundef %mode, i8* noundef %fp) #0 {
1999
+ define %struct.servent* @getservbyport(i32 noundef %port, i8* noundef %proto) #0 {
1868
2000
  entry:
1869
- %voidname.addr = alloca i8*, align 8
1870
- %mode.addr = alloca i8*, align 8
1871
- %fp.addr = alloca i8*, align 8
1872
- store i8* %voidname, i8** %voidname.addr, align 8
1873
- store i8* %mode, i8** %mode.addr, align 8
1874
- store i8* %fp, i8** %fp.addr, align 8
1875
- %0 = load i8*, i8** %fp.addr, align 8
1876
- ret i8* %0
2001
+ %port.addr = alloca i32, align 4
2002
+ %proto.addr = alloca i8*, align 8
2003
+ store i32 %port, i32* %port.addr, align 4
2004
+ store i8* %proto, i8** %proto.addr, align 8
2005
+ %call = call i8* @malloc(i64 noundef 10)
2006
+ %0 = bitcast i8* %call to %struct.servent*
2007
+ ret %struct.servent* %0
1877
2008
  }
1878
2009
 
1879
2010
  ; Function Attrs: noinline nounwind ssp uwtable
1880
- define i8* @freopen(i8* noundef %voidname, i8* noundef %mode, i8* noundef %fp) #0 {
2011
+ define %struct.spwd* @getspnam(i8* noundef %name) #0 {
1881
2012
  entry:
1882
- %voidname.addr = alloca i8*, align 8
1883
- %mode.addr = alloca i8*, align 8
1884
- %fp.addr = alloca i8*, align 8
1885
- store i8* %voidname, i8** %voidname.addr, align 8
1886
- store i8* %mode, i8** %mode.addr, align 8
1887
- store i8* %fp, i8** %fp.addr, align 8
1888
- %0 = load i8*, i8** %fp.addr, align 8
1889
- ret i8* %0
2013
+ %name.addr = alloca i8*, align 8
2014
+ store i8* %name, i8** %name.addr, align 8
2015
+ %call = call i8* @malloc(i64 noundef 10)
2016
+ %0 = bitcast i8* %call to %struct.spwd*
2017
+ ret %struct.spwd* %0
1890
2018
  }
1891
2019
 
1892
2020
  ; Function Attrs: noinline nounwind ssp uwtable
1893
- define i8* @inet_ntop(i32 noundef %af, i8* noalias noundef %src, i8* noalias noundef %dst, i32 noundef %size) #0 {
2021
+ define i8* @gettext(i8* noundef %msgid) #0 {
1894
2022
  entry:
1895
- %af.addr = alloca i32, align 4
1896
- %src.addr = alloca i8*, align 8
1897
- %dst.addr = alloca i8*, align 8
1898
- %size.addr = alloca i32, align 4
1899
- store i32 %af, i32* %af.addr, align 4
1900
- store i8* %src, i8** %src.addr, align 8
1901
- store i8* %dst, i8** %dst.addr, align 8
1902
- store i32 %size, i32* %size.addr, align 4
1903
- %0 = load i8*, i8** %dst.addr, align 8
1904
- ret i8* %0
2023
+ %msgid.addr = alloca i8*, align 8
2024
+ store i8* %msgid, i8** %msgid.addr, align 8
2025
+ %call = call i8* @malloc(i64 noundef 10)
2026
+ ret i8* %call
1905
2027
  }
1906
2028
 
1907
2029
  ; Function Attrs: noinline nounwind ssp uwtable
1908
- define double @strtod(i8* noundef %str, i8** noundef %endptr) #0 {
2030
+ define %struct.tm* @gmtime(i8* noundef %timer) #0 {
1909
2031
  entry:
1910
- %str.addr = alloca i8*, align 8
1911
- %endptr.addr = alloca i8**, align 8
1912
- store i8* %str, i8** %str.addr, align 8
1913
- store i8** %endptr, i8*** %endptr.addr, align 8
1914
- %0 = load i8*, i8** %str.addr, align 8
1915
- %1 = load i8**, i8*** %endptr.addr, align 8
1916
- store i8* %0, i8** %1, align 8
1917
- ret double 0.000000e+00
2032
+ %timer.addr = alloca i8*, align 8
2033
+ store i8* %timer, i8** %timer.addr, align 8
2034
+ %call = call i8* @malloc(i64 noundef 10)
2035
+ %0 = bitcast i8* %call to %struct.tm*
2036
+ ret %struct.tm* %0
1918
2037
  }
1919
2038
 
1920
2039
  ; Function Attrs: noinline nounwind ssp uwtable
1921
- define float @strtof(i8* noundef %nptr, i8** noundef %endptr) #0 {
2040
+ define i8* @gnu_get_libc_version() #0 {
1922
2041
  entry:
1923
- %nptr.addr = alloca i8*, align 8
1924
- %endptr.addr = alloca i8**, align 8
1925
- store i8* %nptr, i8** %nptr.addr, align 8
1926
- store i8** %endptr, i8*** %endptr.addr, align 8
1927
- %0 = load i8*, i8** %nptr.addr, align 8
1928
- %1 = load i8**, i8*** %endptr.addr, align 8
1929
- store i8* %0, i8** %1, align 8
1930
- ret float 0.000000e+00
2042
+ %call = call i8* @malloc(i64 noundef 10)
2043
+ ret i8* %call
1931
2044
  }
1932
2045
 
1933
2046
  ; Function Attrs: noinline nounwind ssp uwtable
1934
- define i64 @strtol(i8* noundef %str, i8** noundef %endptr, i32 noundef %base) #0 {
2047
+ define i8* @gnutls_check_version(i8* noundef %req_version) #0 {
1935
2048
  entry:
1936
- %str.addr = alloca i8*, align 8
1937
- %endptr.addr = alloca i8**, align 8
1938
- %base.addr = alloca i32, align 4
1939
- store i8* %str, i8** %str.addr, align 8
1940
- store i8** %endptr, i8*** %endptr.addr, align 8
1941
- store i32 %base, i32* %base.addr, align 4
1942
- %0 = load i8*, i8** %str.addr, align 8
1943
- %1 = load i8**, i8*** %endptr.addr, align 8
1944
- store i8* %0, i8** %1, align 8
1945
- ret i64 0
2049
+ %req_version.addr = alloca i8*, align 8
2050
+ store i8* %req_version, i8** %req_version.addr, align 8
2051
+ %call = call i8* @malloc(i64 noundef 10)
2052
+ ret i8* %call
1946
2053
  }
1947
2054
 
1948
2055
  ; Function Attrs: noinline nounwind ssp uwtable
1949
- define x86_fp80 @strtold(i8* noundef %str, i8** noundef %endptr) #0 {
2056
+ define %struct.lconv* @localeconv() #0 {
1950
2057
  entry:
1951
- %str.addr = alloca i8*, align 8
1952
- %endptr.addr = alloca i8**, align 8
1953
- store i8* %str, i8** %str.addr, align 8
1954
- store i8** %endptr, i8*** %endptr.addr, align 8
1955
- %0 = load i8*, i8** %str.addr, align 8
1956
- %1 = load i8**, i8*** %endptr.addr, align 8
1957
- store i8* %0, i8** %1, align 8
1958
- ret x86_fp80 0xK00000000000000000000
2058
+ %call = call i8* @malloc(i64 noundef 10)
2059
+ %0 = bitcast i8* %call to %struct.lconv*
2060
+ ret %struct.lconv* %0
1959
2061
  }
1960
2062
 
1961
2063
  ; Function Attrs: noinline nounwind ssp uwtable
1962
- define i64 @strtoul(i8* noundef %str, i8** noundef %endptr, i32 noundef %base) #0 {
2064
+ define %struct.tm* @localtime(i8* noundef %timer) #0 {
1963
2065
  entry:
1964
- %str.addr = alloca i8*, align 8
1965
- %endptr.addr = alloca i8**, align 8
1966
- %base.addr = alloca i32, align 4
1967
- store i8* %str, i8** %str.addr, align 8
1968
- store i8** %endptr, i8*** %endptr.addr, align 8
1969
- store i32 %base, i32* %base.addr, align 4
1970
- %0 = load i8*, i8** %str.addr, align 8
1971
- %1 = load i8**, i8*** %endptr.addr, align 8
1972
- store i8* %0, i8** %1, align 8
1973
- ret i64 0
2066
+ %timer.addr = alloca i8*, align 8
2067
+ store i8* %timer, i8** %timer.addr, align 8
2068
+ %call = call i8* @malloc(i64 noundef 10)
2069
+ %0 = bitcast i8* %call to %struct.tm*
2070
+ ret %struct.tm* %0
1974
2071
  }
1975
2072
 
1976
2073
  ; Function Attrs: noinline nounwind ssp uwtable
1977
- define i32 @readdir_r(i8* noundef %__restrict__dir, i8* noundef %__restrict__entry, i8** noundef %__restrict__result) #0 {
2074
+ define i8* @ngettext(i8* noundef %msgid, i8* noundef %msgid_plural, i64 noundef %n) #0 {
1978
2075
  entry:
1979
- %__restrict__dir.addr = alloca i8*, align 8
1980
- %__restrict__entry.addr = alloca i8*, align 8
1981
- %__restrict__result.addr = alloca i8**, align 8
1982
- store i8* %__restrict__dir, i8** %__restrict__dir.addr, align 8
1983
- store i8* %__restrict__entry, i8** %__restrict__entry.addr, align 8
1984
- store i8** %__restrict__result, i8*** %__restrict__result.addr, align 8
1985
- %0 = load i8**, i8*** %__restrict__result.addr, align 8
1986
- %1 = load i8*, i8** %0, align 8
1987
- store i8* %1, i8** %__restrict__entry.addr, align 8
1988
- ret i32 0
2076
+ %msgid.addr = alloca i8*, align 8
2077
+ %msgid_plural.addr = alloca i8*, align 8
2078
+ %n.addr = alloca i64, align 8
2079
+ store i8* %msgid, i8** %msgid.addr, align 8
2080
+ store i8* %msgid_plural, i8** %msgid_plural.addr, align 8
2081
+ store i64 %n, i64* %n.addr, align 8
2082
+ %call = call i8* @malloc(i64 noundef 10)
2083
+ ret i8* %call
1989
2084
  }
1990
2085
 
1991
2086
  ; Function Attrs: noinline nounwind ssp uwtable
1992
- define i32 @getpwnam_r(i8* noundef %name, i8* noundef %pwd, i8* noundef %buf, i64 noundef %buflen, i8** noundef %result) #0 {
2087
+ define i8* @pango_cairo_font_map_get_default() #0 {
1993
2088
  entry:
1994
- %name.addr = alloca i8*, align 8
1995
- %pwd.addr = alloca i8*, align 8
1996
- %buf.addr = alloca i8*, align 8
1997
- %buflen.addr = alloca i64, align 8
1998
- %result.addr = alloca i8**, align 8
1999
- store i8* %name, i8** %name.addr, align 8
2000
- store i8* %pwd, i8** %pwd.addr, align 8
2001
- store i8* %buf, i8** %buf.addr, align 8
2002
- store i64 %buflen, i64* %buflen.addr, align 8
2003
- store i8** %result, i8*** %result.addr, align 8
2004
- %0 = load i8*, i8** %pwd.addr, align 8
2005
- %1 = load i8**, i8*** %result.addr, align 8
2006
- store i8* %0, i8** %1, align 8
2007
- ret i32 0
2089
+ %call = call i8* @malloc(i64 noundef 10)
2090
+ ret i8* %call
2008
2091
  }
2009
2092
 
2010
2093
  ; Function Attrs: noinline nounwind ssp uwtable
2011
- define i32 @getpwuid_r(i32 noundef %uid, i8* noundef %pwd, i8* noundef %buf, i64 noundef %buflen, i8** noundef %result) #0 {
2094
+ define i8* @re_comp(i8* noundef %regex) #0 {
2012
2095
  entry:
2013
- %uid.addr = alloca i32, align 4
2014
- %pwd.addr = alloca i8*, align 8
2015
- %buf.addr = alloca i8*, align 8
2016
- %buflen.addr = alloca i64, align 8
2017
- %result.addr = alloca i8**, align 8
2018
- store i32 %uid, i32* %uid.addr, align 4
2019
- store i8* %pwd, i8** %pwd.addr, align 8
2020
- store i8* %buf, i8** %buf.addr, align 8
2021
- store i64 %buflen, i64* %buflen.addr, align 8
2022
- store i8** %result, i8*** %result.addr, align 8
2023
- %0 = load i8*, i8** %pwd.addr, align 8
2024
- %1 = load i8**, i8*** %result.addr, align 8
2025
- store i8* %0, i8** %1, align 8
2026
- ret i32 0
2096
+ %regex.addr = alloca i8*, align 8
2097
+ store i8* %regex, i8** %regex.addr, align 8
2098
+ %call = call i8* @malloc(i64 noundef 10)
2099
+ ret i8* %call
2027
2100
  }
2028
2101
 
2029
2102
  ; Function Attrs: noinline nounwind ssp uwtable
2030
- define void @_ZNSt8__detail15_List_node_base7_M_hookEPS0_(i8* noundef %arg0, i8** noundef %arg1) #0 {
2103
+ define i8* @setlocale(i32 noundef %category, i8* noundef %locale) #0 {
2031
2104
  entry:
2032
- %arg0.addr = alloca i8*, align 8
2033
- %arg1.addr = alloca i8**, align 8
2034
- store i8* %arg0, i8** %arg0.addr, align 8
2035
- store i8** %arg1, i8*** %arg1.addr, align 8
2036
- %0 = load i8*, i8** %arg0.addr, align 8
2037
- %1 = load i8**, i8*** %arg1.addr, align 8
2038
- store i8* %0, i8** %1, align 8
2039
- ret void
2105
+ %category.addr = alloca i32, align 4
2106
+ %locale.addr = alloca i8*, align 8
2107
+ store i32 %category, i32* %category.addr, align 4
2108
+ store i8* %locale, i8** %locale.addr, align 8
2109
+ %call = call i8* @malloc(i64 noundef 10)
2110
+ ret i8* %call
2040
2111
  }
2041
2112
 
2042
2113
  ; Function Attrs: noinline nounwind ssp uwtable
2043
- define i8* @__dynamic_cast(i8* noundef %source, i8* noundef %sourceTypeInfo, i8* noundef %targetTypeInfo, i64 noundef %castType) #0 {
2114
+ define i8* @tgoto(i8* noundef %cap, i32 noundef %col, i32 noundef %row) #0 {
2044
2115
  entry:
2045
- %source.addr = alloca i8*, align 8
2046
- %sourceTypeInfo.addr = alloca i8*, align 8
2047
- %targetTypeInfo.addr = alloca i8*, align 8
2048
- %castType.addr = alloca i64, align 8
2049
- store i8* %source, i8** %source.addr, align 8
2050
- store i8* %sourceTypeInfo, i8** %sourceTypeInfo.addr, align 8
2051
- store i8* %targetTypeInfo, i8** %targetTypeInfo.addr, align 8
2052
- store i64 %castType, i64* %castType.addr, align 8
2053
- %0 = load i8*, i8** %source.addr, align 8
2054
- ret i8* %0
2116
+ %cap.addr = alloca i8*, align 8
2117
+ %col.addr = alloca i32, align 4
2118
+ %row.addr = alloca i32, align 4
2119
+ store i8* %cap, i8** %cap.addr, align 8
2120
+ store i32 %col, i32* %col.addr, align 4
2121
+ store i32 %row, i32* %row.addr, align 4
2122
+ %call = call i8* @malloc(i64 noundef 10)
2123
+ ret i8* %call
2055
2124
  }
2056
2125
 
2057
2126
  ; Function Attrs: noinline nounwind ssp uwtable
2058
- define void @_ZNSsC1EPKcRKSaIcE(i8** noundef %arg0, i8* noundef %arg1) #0 {
2127
+ define i8* @tparm(i8* noundef %str, ...) #0 {
2059
2128
  entry:
2060
- %arg0.addr = alloca i8**, align 8
2061
- %arg1.addr = alloca i8*, align 8
2062
- store i8** %arg0, i8*** %arg0.addr, align 8
2063
- store i8* %arg1, i8** %arg1.addr, align 8
2064
- %0 = load i8*, i8** %arg1.addr, align 8
2065
- %1 = load i8**, i8*** %arg0.addr, align 8
2066
- store i8* %0, i8** %1, align 8
2067
- ret void
2129
+ %str.addr = alloca i8*, align 8
2130
+ store i8* %str, i8** %str.addr, align 8
2131
+ %call = call i8* @malloc(i64 noundef 10)
2132
+ ret i8* %call
2068
2133
  }
2069
2134
 
2070
2135
  ; Function Attrs: noinline nounwind ssp uwtable
2071
- define void @_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_(i8** noundef %arg0, i8* noundef %arg1) #0 {
2136
+ define i8* @zError(i32 noundef %a) #0 {
2072
2137
  entry:
2073
- %arg0.addr = alloca i8**, align 8
2074
- %arg1.addr = alloca i8*, align 8
2075
- store i8** %arg0, i8*** %arg0.addr, align 8
2076
- store i8* %arg1, i8** %arg1.addr, align 8
2077
- %0 = load i8*, i8** %arg1.addr, align 8
2078
- %1 = load i8**, i8*** %arg0.addr, align 8
2079
- store i8* %0, i8** %1, align 8
2080
- ret void
2138
+ %a.addr = alloca i32, align 4
2139
+ store i32 %a, i32* %a.addr, align 4
2140
+ %call = call i8* @malloc(i64 noundef 10)
2141
+ ret i8* %call
2081
2142
  }
2082
2143
 
2083
2144
  attributes #0 = { noinline nounwind ssp uwtable "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" }