NAME=td anonymous struct in typedef
FILE==
CMDS=<<EOF
td "typedef struct {int a;} Foo;"
td "typedef struct { char *hello; int world[]; } Bar;"
ts~Foo,Bar
tt~Foo
tt~Bar
ts "anonymous struct 0"
ts "anonymous struct 1"
EOF
EXPECT=<<EOF
Foo = struct anonymous struct 0
Bar = struct anonymous struct 1
pf "d a"
pf "z[0]d hello world"
EOF
RUN

NAME=types - global var
FILE==
CMDS=<<EOF
e asm.bytes=true
e asm.arch=x86
e asm.bits=64
wx 41574156415541544989f4555389fd4881eca8030000488b3e64488b042528000000488984249803000031c0e82fb30000488d35d54e0100bf06000000
e asm.comments=false
s 2
avga bla short
sd +6
avga foo int
s 0
pd 8
EOF
EXPECT=<<EOF
            0x00000000      4157           push  r15
(short bla)
 short : 0x00000002 = 0x5641
            0x00000004      4155           push  r13
            0x00000006      4154           push  r12
(int foo)
 int : 0x00000008 = 1442089289
            0x0000000c      53             push  rbx
            0x0000000d      89fd           mov   ebp, edi
            0x0000000f      4881eca80300.  sub   rsp, 0x3a8
EOF
RUN

NAME=types - global var 2
FILE==
CMDS=<<EOF
e asm.bytes=true
e asm.arch=x86
e asm.bits=64
wx 48656c6c341248656c6c6f00000000000000000048656c6c6f0000000000000000009090
td "typedef uint16_t WORD;"
td "typedef struct _VbHeader { char szVbMagic[4]; WORD wRuntimeBuild; char szLangDll[14]; char szSecLangDll[14];} VbHeader;"
avga vbb VbHeader @ 0
pd 3
EOF
EXPECT=<<EOF
(VbHeader vbb)
     szVbMagic : 0x00000000 = [ 'H', 'e', 'l', 'l' ]
 wRuntimeBuild : 0x00000004 = 0x1234
     szLangDll : 0x00000006 = [ 'H', 'e', 'l', 'l', 'o', '.', '.', '.', '.', '.', '.', '.', '.', '.' ]
  szSecLangDll : 0x00000014 = [ 'H', 'e', 'l', 'l', 'o', '.', '.', '.', '.', '.', '.', '.', '.', '.' ]
            0x00000022      90             nop
            0x00000023      90             nop
EOF
RUN

NAME=Global variables with types - JSON
FILE==
CMDS=<<EOF
wx 41574156415541544989f4555389fd4881eca8030000488b3e64488b042528000000488984249803000031c0e82fb30000488d35d54e0100bf06000000
s 2
avga bla short
sd +6
avga foo int
avgj
EOF
EXPECT=<<EOF
[{"name":"bla","type":"short","addr":"0x2"},{"name":"foo","type":"int","addr":"0x8"}]
EOF
RUN

NAME=List global variable with types
FILE==
CMDS=<<EOF
avga bla int @ 0x4
w test @ 0x10
avga foo "char *" @ 0x10
avg
EOF
EXPECT=<<EOF
global int bla @ 0x4
global char * foo @ 0x10
EOF
RUN

NAME=jni and SoP
BROKEN=1
FILE=bins/elf/libverifyPass.so
CMDS=<<EOF
e asm.bytes=true
e asm.lines.bb=false
aa
s sym.Java_com_app_ndh_NDHActivity_print
# TODO: Tracked in https://github.com/rizinorg/rizin/issues/1132
# This is actually quite wrong, regarding what this function actually does :-)
# We are manually crafting the canary value such that it looks like a pointer
# and say that at this pointer there is a JNINativeInterface object, in order
# to test propagation from a global variable.
# Do not hesitate to edit this test if you find a better case for testing this.
e io.cache=1
wx 37133713 @ reloc.target.__stack_chk_guard

# TODO: Requires preprocessor that isn't implemented yet
# This is tracked in https://github.com/rizinorg/rizin/issues/1204
to bins/headers/jni.h
avga bla JNINativeInterface @ 0x13371337
avga foo JNINativeInterface @ 0x464c457f # \x7fELF, the "pointer" when dereferencing addr 0
aat

pdf~JNINativeInterface
pdr~JNI?
EOF
EXPECT=<<EOF
| ; var struct JNINativeInterface @ sp+0x12c
| 0x00000f74      4b93           str   r3, [JNINativeInterface]
| 0x00000f76      039b           ldr   r3, [var_134h]                  ; JNINativeInterface.reserved0
| 0x00000f7e      d358           ldr   r3, [r2, r3]                    ; JNINativeInterface.GetStringUTFChars
| 0x00000f82      019a           ldr   r2, [var_13ch]                  ; JNINativeInterface.reserved0
| 0x0000100e      d358           ldr   r3, [r2, r3]                    ; JNINativeInterface.GetStringLength
| 0x00001012      019a           ldr   r2, [var_13ch]                  ; JNINativeInterface.reserved0
| 0x00001066      d258           ldr   r2, [r2, r3]                    ; JNINativeInterface.NewStringUTF
| 0x00001114      d258           ldr   r2, [r2, r3]                    ; JNINativeInterface.NewStringUTF
| 0x0000112e      d258           ldr   r2, [r2, r3]                    ; JNINativeInterface.NewStringUTF
| 0x00001144      4b9a           ldr   r2, [JNINativeInterface]
| 0x00001148      9a42           cmp   r2, r3                          ; JNINativeInterface.reserved0
12
EOF
RUN

NAME=jni and SoP (preprocessed)
FILE=bins/elf/libverifyPass.so
BROKEN=1
CMDS=<<EOF
e asm.bytes=true
e asm.lines.bb=false
aa
s sym.Java_com_app_ndh_NDHActivity_print
to bins/headers/jni_preprocessed.h

# TODO: Tracked in https://github.com/rizinorg/rizin/issues/1132
# This is actually quite wrong, regarding what this function actually does :-)
# We are manually crafting the canary value such that it looks like a pointer
# and say that at this pointer there is a JNINativeInterface object, in order
# to test propagation from a global variable.
# Do not hesitate to edit this test if you find a better case for testing this.
e io.cache=1
wx 37133713 @ reloc.target.__stack_chk_guard
avga bla JNINativeInterface @ 0x13371337
avga foo JNINativeInterface @ 0x464c457f # \x7fELF, the "pointer" when dereferencing addr 0
aat

pdf~JNINativeInterface
pdr~JNI?
EOF
EXPECT=<<EOF
| ; var struct JNINativeInterface JNINativeInterface @ stack - 0x14
| 0x00000f74      4b93           str   r3, [JNINativeInterface.reserved0]
| 0x00000f76      039b           ldr   r3, [var_134h]                  ; JNINativeInterface.reserved0
| 0x00000f7e      d358           ldr   r3, [r2, r3]                    ; JNINativeInterface.GetStringUTFChars
| 0x00000f82      019a           ldr   r2, [var_13ch]                  ; JNINativeInterface.reserved0
| 0x0000100e      d358           ldr   r3, [r2, r3]                    ; JNINativeInterface.GetStringLength
| 0x00001012      019a           ldr   r2, [var_13ch]                  ; JNINativeInterface.reserved0
| 0x00001066      d258           ldr   r2, [r2, r3]                    ; JNINativeInterface.NewStringUTF
| 0x00001114      d258           ldr   r2, [r2, r3]                    ; JNINativeInterface.NewStringUTF
| 0x0000112e      d258           ldr   r2, [r2, r3]                    ; JNINativeInterface.NewStringUTF
| 0x00001144      4b9a           ldr   r2, [JNINativeInterface.reserved0]
| 0x00001148      9a42           cmp   r2, r3                          ; JNINativeInterface.reserved0
12
EOF
RUN

NAME=t
FILE==
ARGS=-b 64
CMDS=<<EOF
t char
t double
t "long double"
t float
t int
t short
t long
t "long long"
t size_t
t uid_t
t int8_t
t uint8_t
t int16_t
t uint16_t
t int32_t
t uint32_t
t int64_t
t uint64_t
t char16_t
t void
EOF
EXPECT=<<EOF
pf "c char"
pf "F double"
pf "F long double"
pf "f float"
pf "d int"
pf "w short"
pf "x long"
pf "q long long"
pf "q size_t"
pf "q uid_t"
pf "b int8_t"
pf "b uint8_t"
pf "w int16_t"
pf "w uint16_t"
pf "d int32_t"
pf "d uint32_t"
pf "q int64_t"
pf "q uint64_t"
pf "c char16_t"
EOF
RUN

NAME=t <type>
FILE==
CMDS=<<EOF
t int
t-*
t int
EOF
EXPECT=<<EOF
pf "d int"
EOF
EXPECT_ERR=<<EOF
ERROR: core: cannot find 'int' type
EOF
RUN

NAME=t- enum
FILE==
CMDS=<<EOF
td "enum pe_machine { IMAGE_FILE_MACHINE_IA64=0x200, IMAGE_FILE_MACHINE_I386=0x14c };"
te~?pe_machine
t- pe_machine
te~?pe_machine
EOF
EXPECT=<<EOF
1
0
EOF
RUN

NAME=t- struct
FILE==
CMDS=<<EOF
t-*
td "struct three_elements{int x; char y; float z;}"
t- three_elements
ts~?
EOF
EXPECT=<<EOF
0
EOF
RUN

NAME=t- union
FILE==
CMDS=<<EOF
td "union xoo{int x; int y; int z;}"
tu xoo
tuc xoo
t- xoo
tu xoo
tuc xoo
EOF
EXPECT=<<EOF
pf "0ddd x y z"
union xoo {
	int x;
	int y;
	int z;
};
EOF
EXPECT_ERR=<<EOF
ERROR: core: cannot find 'xoo' type
ERROR: Cannot find "xoo" union type
EOF
RUN

NAME=td with comments
FILE==
CMDS=<<EOF
td "typedef /* fff */ unsigned int uint; // ggg "
td "union bla { uint b; /* qwe */ };"
td "struct foo { uint b; /* qwe */ char *foo[5]; };"
td "enum bar { A = 0, /* qwe */ B, G, /* ewq */ }"
tu bla
tuc bla
ts foo
tsc foo
te bar
tec bar
EOF
EXPECT=<<EOF
pf "0i b"
union bla {
	uint b;
};
pf "i[5]*c b foo"
struct foo {
	uint b;
	char *foo[5];
};
A = 0x0
B = 0x1
G = 0x2
enum bar {
	A = 0x0,
	B = 0x1,
	G = 0x2
};
EOF
RUN

NAME=typedef
FILE==
CMDS=<<EOF
td "typedef int Abracadabra"
t- Abracadabra
t~?Abracadabra
EOF
EXPECT=<<EOF
0
EOF
RUN

NAME=typedef function
FILE==
CMDS=<<EOF
td "typedef uint8_t ( *bla)(const char *bla, void *foo);"
tt bla
ttc bla
tf bla
EOF
EXPECT=<<EOF
bla = uint8_t (*bla)(const char *bla, void *foo)
typedef uint8_t (*bla)(const char *bla, void *foo);
uint8_t bla(const char *bla, void *foo);
EOF
RUN

NAME=typedef const char***
FILE==
CMDS=<<EOF
td "typedef const char*** foo_t"
td "typedef const char *** const *** const * const * const boo_t"
tt foo_t
tt boo_t
EOF
EXPECT=<<EOF
foo_t = const char ***
boo_t = const char *** const *** const * const * const 
EOF
RUN

NAME=typedef self-reference
FILE=bins/elf/analysis/self-ref-typedef
CMDS=<<EOF
tt const_reference
ttc const_reference
t const_reference
tc const_reference
tc const_reference_0
EOF
EXPECT=<<EOF
const_reference = struct const_reference_0
typedef struct const_reference_0 const_reference;
pf "d a"
const_reference;
struct const_reference_0 {
	int a;
};
EOF
RUN


NAME=t-*
FILE==
CMDS=<<EOF
td "enum pe_machine { IMAGE_FILE_MACHINE_IA64=0x200, IMAGE_FILE_MACHINE_I386=0x14c };"
t-*
t
EOF
EXPECT=<<EOF
EOF
RUN

NAME=teb
FILE==
CMDS=<<EOF
td "enum pe_machine { IMAGE_FILE_MACHINE_IA64=0x200, IMAGE_FILE_MACHINE_I386=0x14c };"
teb pe_machine IMAGE_FILE_MACHINE_I386
EOF
EXPECT=<<EOF
0x14c
EOF
RUN

NAME=te
FILE==
CMDS=<<EOF
td "enum pe_machine { IMAGE_FILE_MACHINE_IA64=0x200, IMAGE_FILE_MACHINE_I386=0x14c };"
te pe_machine 0x14c
EOF
EXPECT=<<EOF
IMAGE_FILE_MACHINE_I386
EOF
RUN

NAME=tef
FILE==
CMDS=<<EOF
td "enum FOO { A=1, B=0x100, C=0xFF, D=4, E=5 };"
td "enum BAR { G=0x800, Z=0xEE, P=4, E=5 };"
tef 0x800
tef 0x100
tef 4~FOO.D
tef 4~BAR.P
tef 5~FOO.E
tef 5~BAR.E
EOF
EXPECT=<<EOF
BAR.G
FOO.B
FOO.D
BAR.P
FOO.E
BAR.E
EOF
RUN

NAME=tej
FILE==
CMDS=<<EOF
td "enum FOO { A=1, B=0x100, C=0xFF, D=4, E=5 };"
td "enum BAR { G=0x800, Z=0xEE, P=4, E=5 };"
tej FOO
tej BAR
EOF
EXPECT=<<EOF
{"name":"FOO","values":{"A":1,"B":256,"C":255,"D":4,"E":5}}
{"name":"BAR","values":{"G":2048,"Z":238,"P":4,"E":5}}
EOF
RUN

NAME=tf
FILE==
CMDS=<<EOF
tf write
EOF
EXPECT=<<EOF
ssize_t write(int fd, const char *ptr, size_t nbytes);
EOF
RUN

NAME=tt
FILE==
CMDS=<<EOF
td "typedef char FILE_NAME;"
tt FILE_NAME
td "typedef bool FLAG;"
tt FLAG
EOF
EXPECT=<<EOF
FILE_NAME = char
FLAG = bool
EOF
RUN

NAME=td struct
FILE==
CMDS=<<EOF
td "struct test_struct{int x;int y;};"
ts test_struct
tsd test_struct
td "typedef uint16_t word;"
td "typedef uint32_t dword;"
td "struct test_struct2{word a; word b[5]; word c; word d[10]; dword e;};"
ts test_struct2
tsd test_struct2
EOF
EXPECT=<<EOF
pf "dd x y"
struct test_struct { int x; int y; };
pf "w[5]ww[10]wd a (word)b c (word)d e"
struct test_struct2 { word a; word b[5]; word c; word d[10]; dword e; };
EOF
RUN

NAME=td struct with attribute
FILE==
CMDS=<<EOF
td "struct test_struct {int x;int y;} __attribute__((__packed__));"
ts test_struct
tsd test_struct
EOF
EXPECT=<<EOF
pf "dd x y"
struct test_struct { int x; int y; };
EOF
RUN

NAME=enum32
FILE==
CMDS=<<EOF
td "enum v { t=0x123, p=0x321 };"
tcd v
tc v
tec v
te v
te v 0x123
te v 0x321
EOF
EXPECT=<<EOF
enum v { t = 0x123, p = 0x321 };
enum v {
	t = 0x123,
	p = 0x321
};
enum v {
	t = 0x123,
	p = 0x321
};
t = 0x123
p = 0x321
t
p
EOF
RUN

NAME=enum64
FILE==
CMDS=<<EOF
td "enum v { t=0x8000000000000001, p=0x8000000000000008 };"
tcd v
tc v
tec v
te v
te v 0x8000000000000001
te v 0x8000000000000008
EOF
EXPECT=<<EOF
enum v { t = 0x8000000000000001, p = 0x8000000000000008 };
enum v {
	t = 0x8000000000000001,
	p = 0x8000000000000008
};
enum v {
	t = 0x8000000000000001,
	p = 0x8000000000000008
};
t = 0x8000000000000001
p = 0x8000000000000008
t
p
EOF
RUN

NAME=enhanced enum
FILE==
CMDS=<<EOF
td "enum v : int { t=0x123, p=0x321 };"
tcd v
tc v
tec v
te v
te v 0x123
te v 0x321
td "enum w : long long { t=0x123, p=0x321 };"
tcd w
tc w
tec w
te w
te w 0x123
te w 0x321
EOF
EXPECT=<<EOF
enum v { t = 0x123, p = 0x321 };
enum v {
	t = 0x123,
	p = 0x321
};
enum v {
	t = 0x123,
	p = 0x321
};
t = 0x123
p = 0x321
t
p
enum w { t = 0x123, p = 0x321 };
enum w {
	t = 0x123,
	p = 0x321
};
enum w {
	t = 0x123,
	p = 0x321
};
t = 0x123
p = 0x321
t
p
EOF
RUN

NAME=to error.h
FILE==
BROKEN=1
CMDS=<<EOF
to bins/other/error.h
t~char,double,float,int,long,short,size,uid,void # basic universal types
t~addr,date,dox,name
ts~addr,date,dox,name
t addr
EOF
EXPECT_ERR=<<EOF
bins/other/error.h:2: warning: #error your compiler doesn't have support to my API
EOF
EXPECT=<<EOF
char
char *
double
float
int
int16_t
int32_t
int64_t
int8_t
long
long long
short
size_t
uid_t
uint16_t
uint32_t
uint64_t
uint8_t
unsigned char
unsigned int
unsigned short
void *
addr
addr_t
date
date_t
dox
dox_t
name
name_t
pf "[127]z[40]zd street city zip"
EOF
RUN

NAME=to test.h
FILE==
CMDS=<<EOF
to bins/other/test.h
ts name
tsd name
tsc name
ts date
tsd date
tsc date
ts addr
tsd addr
tsc addr
tsd dox
tsc dox
tt name_t
ttc name_t
tt date_t
ttc date_t
tt addr_t
ttc addr_t
tt dox_t
ttc dox_t
EOF
EXPECT=<<EOF
pf "[40]c[40]c[40]c first middle last"
struct name { char first[40]; char middle[40]; char last[40]; };
struct name {
	char first[40];
	char middle[40];
	char last[40];
};
pf "bbw day month year"
struct date { uint8_t day; uint8_t month; uint16_t year; };
struct date {
	uint8_t day;
	uint8_t month;
	uint16_t year;
};
pf "[127]c[40]cd street city zip"
struct addr { char street[127]; char city[40]; uint32_t zip; };
struct addr {
	char street[127];
	char city[40];
	uint32_t zip;
};
struct dox { addr_t address; name_t name; date_t bday; };
struct dox {
	addr_t address;
	name_t name;
	date_t bday;
};
name_t = struct name
typedef struct name name_t;
date_t = struct date
typedef struct date date_t;
addr_t = struct addr
typedef struct addr addr_t;
dox_t = struct dox
typedef struct dox dox_t;
EOF
RUN

NAME=unions
FILE==
CMDS=<<EOF
td "union x{float a;int b;}"
tu x
tuc x
EOF
EXPECT=<<EOF
pf "0fd a b"
union x {
	float a;
	int b;
};
EOF
RUN

NAME=td twice
FILE==
CMDS=<<EOF
td "int foo(int bar);"
td "int foo(int bar);"
tf~foo
EOF
EXPECT=<<EOF
int foo(int bar);
EOF
RUN

NAME=struct of struct with ts and pf
FILE==
CMDS=<<EOF
td "struct bar { int a; int b; };"
td "struct foo { int x; struct bar moo; };"
ts foo
.ts foo
EOF
EXPECT=<<EOF
pf "d? x (bar)moo"
   x : 0x00000000 = 0
 moo : 
                struct<bar>
   a : 0x00000004 = 0
   b : 0x00000008 = 0
EOF
RUN

NAME=Array of struct with ts
FILE==
CMDS=<<EOF
td "struct bar { int a; int b; };"
td "struct foo { int x; struct bar moo[2]; };"
ts foo
.ts foo
EOF
EXPECT=<<EOF
pf "d[2]? x (bar)moo"
   x : 0x00000000 = 0
 moo : 
[
                struct<bar>
   a : 0x00000004 = 0
   b : 0x00000008 = 0

                struct<bar>
   a : 0x0000000c = 0
   b : 0x00000010 = 0
]
EOF
RUN

NAME=te <enum>
FILE==
CMDS=<<EOF
td "enum Foo {COW=1,BAR=2};"
te~Foo
te Foo
EOF
EXPECT=<<EOF
Foo
COW = 0x1
BAR = 0x2
EOF
RUN

NAME=te <enum> <value>
FILE==
CMDS=<<EOF
td "enum Foo {COW=1,BAR=2};"
te Foo 1
EOF
EXPECT=<<EOF
COW
EOF
RUN

NAME=teb <enum> <name>
FILE==
CMDS=<<EOF
td "enum Foo {COW=1,BAR=2};"
teb Foo COW
EOF
EXPECT=<<EOF
0x1
EOF
RUN

NAME=tp struct
FILE==
CMDS=<<EOF
td "struct person { int age; char name[10]; }"
s 14
w Carlos
s 10
wx 13
tp person @ 10
tp person 10
EOF
EXPECT=<<EOF
  age : 0x0000000a = 19
 name : 0x0000000e = [ 'C', 'a', 'r', 'l', 'o', 's', '.', '.', '.', '.' ]
  age : 0x0000000a = 19
 name : 0x0000000e = [ 'C', 'a', 'r', 'l', 'o', 's', '.', '.', '.', '.' ]
EOF
RUN

NAME=tp union
FILE==
CMDS=<<EOF
e asm.arch=arm
e asm.bits=64
td "union bla { int a; int b; float c; }"
td "struct foo { union poo { int a; int b; long long c; } q; char *p; }"
td "struct alb { int a; union moo { int t; char b; long long c; } f; void *goo; }"
td "struct simple { union y { int a; int b; } g; void *val_4; void *val_5; void *val_6; }"
wx 13ffaa00
s 8
w Carlossssssssssssssssssssssssssssss
s 10
t bla
tp bla @ 0
t foo
tp foo @ 0
t alb
tp alb @ 0
t simple
tp simple @ 0
EOF
EXPECT=<<EOF
pf "0ddf a b c"
 a : 0x00000000 = 11206419
 b : 0x00000000 = 11206419
 c : 0x00000000 = 1.57035377e-38
pf "?z (poo)q p"
 q : 
                 union<poo>
   a : 0x00000000 = 11206419
   b : 0x00000000 = 11206419
   c : 0x00000000 = (qword)0x0000000000aaff13
 p : 0x00000008 = "Carlossssssssssssssssssssssssssssss"
pf "d?p a (moo)f goo"
   a : 0x00000000 = 11206419
   f : 
                 union<moo>
   t : 0x00000004 = 0
   b : 0x00000004 = '.'
   c : 0x00000004 = (qword)0x6c72614300000000
 goo : 0x0000000c = (qword)0x737373737373736f
pf "?ppp (y)g val_4 val_5 val_6"
     g : 
                 union<y>
   a : 0x00000000 = 11206419
   b : 0x00000000 = 11206419
 val_4 : 0x00000004 = (qword)0x6c72614300000000
 val_5 : 0x0000000c = (qword)0x737373737373736f
 val_6 : 0x00000014 = (qword)0x7373737373737373
EOF
RUN

NAME=tp blocksize
FILE==
BROKEN=1
CMDS=<<EOF
e asm.arch=x86
wx 790a790a790a790a790a790a790a790a790a
td "struct foobar{uint32_t a; uint32_t b; uint32_t c; uint32_t d;}"
b 10
tp foobar
b 16
tp foobar
EOF
EXPECT=<<EOF
 a : 0x00000000 = 175704697
 b : 0x00000004 = 175704697
 c : 0x00000008 = 175704697
 d : 0x0000000c = 175704697
 a : 0x00000000 = 175704697
 b : 0x00000004 = 175704697
 c : 0x00000008 = 175704697
 d : 0x0000000c = 175704697
EOF
RUN

NAME=tpv
FILE==
CMDS=<<EOF
e asm.arch=x86
e asm.bits=16
e cfg.bigendian=false
td "struct s16ui { uint16_t a_u; int16_t b_i; uint16_t c_u; int16_t d_i;}"
td "struct s16iu { int16_t a_i; uint16_t b_u; int16_t c_i; uint16_t d_u;}"
td "struct s32ui { uint32_t e_u; int16_t f_i;}"
td "struct s32iu { int32_t e_i; uint16_t f_u;}"
e cfg.bigendian=true
tpv s16ui 0xcafebabecafebabe
tpv s16iu 0xcafebabecafebabe
tpv s32ui 0xcafebabecafebabe
tpv s32iu 0xcafebabecafebabe
e cfg.bigendian=false
tpv s16ui 0xcafebabecafebabe
tpv s16iu 0xcafebabecafebabe
tpv s32ui 0xcafebabecafebabe
tpv s32iu 0xcafebabecafebabe
e asm.bits=32
e cfg.bigendian=false
td "struct s16ui { uint16_t a_u; int16_t b_i; uint16_t c_u; int16_t d_i;}"
td "struct s16iu { int16_t a_i; uint16_t b_u; int16_t c_i; uint16_t d_u;}"
td "struct s32ui { uint32_t e_u; int16_t f_i;}"
td "struct s32iu { int32_t e_i; uint16_t f_u;}"
e cfg.bigendian=true
tpv s16ui 0xcafebabecafebabe
tpv s16iu 0xcafebabecafebabe
tpv s32ui 0xcafebabecafebabe
tpv s32iu 0xcafebabecafebabe
e cfg.bigendian=false
tpv s16ui 0xcafebabecafebabe
tpv s16iu 0xcafebabecafebabe
tpv s32ui 0xcafebabecafebabe
tpv s32iu 0xcafebabecafebabe
e asm.bits=64
e cfg.bigendian=false
td "struct s16ui { uint16_t a_u; int16_t b_i; uint16_t c_u; int16_t d_i;}"
td "struct s16iu { int16_t a_i; uint16_t b_u; int16_t c_i; uint16_t d_u;}"
td "struct s32ui { uint32_t e_u; int16_t f_i;}"
td "struct s32iu { int32_t e_i; uint16_t f_u;}"
e cfg.bigendian=true
tpv s16ui 0xcafebabecafebabe
tpv s16iu 0xcafebabecafebabe
tpv s32ui 0xcafebabecafebabe
tpv s32iu 0xcafebabecafebabe
e cfg.bigendian=false
tpv s16ui 0xcafebabecafebabe
tpv s16iu 0xcafebabecafebabe
tpv s32ui 0xcafebabecafebabe
tpv s32iu 0xcafebabecafebabe
EOF
EXPECT=<<EOF
 a_u : 0x00000000 = 0xbabe
 b_i : 0x00000002 = 0x0000
 c_u : 0x00000004 = 0x0000
 d_i : 0x00000006 = 0x0000
 a_i : 0x00000000 = 0xbabe
 b_u : 0x00000002 = 0x0000
 c_i : 0x00000004 = 0x0000
 d_u : 0x00000006 = 0x0000
 e_u : 0x00000000 = 3133014016
 f_i : 0x00000004 = 0x0000
 e_i : 0x00000000 = 3133014016
 f_u : 0x00000004 = 0x0000
 a_u : 0x00000000 = 0xbabe
 b_i : 0x00000002 = 0x0000
 c_u : 0x00000004 = 0x0000
 d_i : 0x00000006 = 0x0000
 a_i : 0x00000000 = 0xbabe
 b_u : 0x00000002 = 0x0000
 c_i : 0x00000004 = 0x0000
 d_u : 0x00000006 = 0x0000
 e_u : 0x00000000 = 47806
 f_i : 0x00000004 = 0x0000
 e_i : 0x00000000 = 47806
 f_u : 0x00000004 = 0x0000
 a_u : 0x00000000 = 0xcafe
 b_i : 0x00000002 = 0xbabe
 c_u : 0x00000004 = 0x0000
 d_i : 0x00000006 = 0x0000
 a_i : 0x00000000 = 0xcafe
 b_u : 0x00000002 = 0xbabe
 c_i : 0x00000004 = 0x0000
 d_u : 0x00000006 = 0x0000
 e_u : 0x00000000 = 3405691582
 f_i : 0x00000004 = 0x0000
 e_i : 0x00000000 = 3405691582
 f_u : 0x00000004 = 0x0000
 a_u : 0x00000000 = 0xbabe
 b_i : 0x00000002 = 0xcafe
 c_u : 0x00000004 = 0x0000
 d_i : 0x00000006 = 0x0000
 a_i : 0x00000000 = 0xbabe
 b_u : 0x00000002 = 0xcafe
 c_i : 0x00000004 = 0x0000
 d_u : 0x00000006 = 0x0000
 e_u : 0x00000000 = 3405691582
 f_i : 0x00000004 = 0x0000
 e_i : 0x00000000 = 3405691582
 f_u : 0x00000004 = 0x0000
 a_u : 0x00000000 = 0xcafe
 b_i : 0x00000002 = 0xbabe
 c_u : 0x00000004 = 0xcafe
 d_i : 0x00000006 = 0xbabe
 a_i : 0x00000000 = 0xcafe
 b_u : 0x00000002 = 0xbabe
 c_i : 0x00000004 = 0xcafe
 d_u : 0x00000006 = 0xbabe
 e_u : 0x00000000 = 3405691582
 f_i : 0x00000004 = 0xcafe
 e_i : 0x00000000 = 3405691582
 f_u : 0x00000004 = 0xcafe
 a_u : 0x00000000 = 0xbabe
 b_i : 0x00000002 = 0xcafe
 c_u : 0x00000004 = 0xbabe
 d_i : 0x00000006 = 0xcafe
 a_i : 0x00000000 = 0xbabe
 b_u : 0x00000002 = 0xcafe
 c_i : 0x00000004 = 0xbabe
 d_u : 0x00000006 = 0xcafe
 e_u : 0x00000000 = 3405691582
 f_i : 0x00000004 = 0xbabe
 e_i : 0x00000000 = 3405691582
 f_u : 0x00000004 = 0xbabe
EOF
RUN

NAME=tp with varname
FILE=bins/elf/struct_sample
CMDS=<<EOF
td "struct Books {char  title[50];char  author[50]; char  subject[100];};"
aa
s main
aei
aeim
aecu 0x000006d5
tp Books var_e8h
EOF
EXPECT=<<EOF
   title : 0x00177f18 = [ 'R', 'a', 'd', 'a', 'r', 'e', '2', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' ]
  author : 0x00177f4a = [ 'p', 'a', 'n', 'c', 'a', 'k', 'e', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' ]
 subject : 0x00177f7c = [ 'R', 'e', 'v', 'e', 'r', 's', 'i', 'n', 'g', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' ]
EOF
RUN

NAME=tpx test
FILE==
CMDS=<<EOF
td "struct foo {char* a; int b;}"
tpx foo 41414141441414141414420010000000
EOF
EXPECT=<<EOF
 a : 0x00000000 = "AAAAD\x14\x14\x14\x14\x14B"
 b : 0x0000000c = 16
EOF
RUN

NAME=aht and arm
FILE==
CMDS=<<EOF
e asm.bytes=true
e asm.arch=arm
e asm.bits=32
wx 082090e5040081e5
td "struct foo {int a; int b; int c;};"
aht foo.c @ 0x00000000
aht foo.b @ 0x00000004
pi 2
echo ---
pd 2
EOF
EXPECT=<<EOF
ldr r2, [r0, foo.c]
str r0, [r1, foo.b]
---
            0x00000000      082090e5       ldr   r2, [r0, foo.c]
            0x00000004      040081e5       str   r0, [r1, foo.b]
EOF
RUN

NAME=aht and mips
FILE==
CMDS=<<EOF
e asm.bytes=true
e asm.arch=mips
wx 08007fac040053800800538c
td "struct foo {int a; int b; int c;};"
aht foo.c @ 0x00000000
aht foo.c @ 0x00000008
aht foo.b @ 0x00000004
pi 3
echo ---
pd 3
EOF
EXPECT=<<EOF
sw ra, foo.c(v1)
lb s3, foo.b(v0)
lw s3, foo.c(v0)
---
            0x00000000      08007fac       sw    ra, foo.c(v1)
            0x00000004      04005380       lb    s3, foo.b(v0)
            0x00000008      0800538c       lw    s3, foo.c(v0)
EOF
RUN

NAME=struct offset for dst operand with aht
FILE==
CMDS=<<EOF
e asm.bytes=true
e asm.arch=x86
e asm.bits=32
td "struct foo {int a; int b ; int c;}"
wx 8b40048951048d500883780800
aht foo.b @ 0x00000000
aht foo.b @ 0x00000003
aht foo.c @ 0x00000006
aht foo.c @ 0x00000009
pi 4
echo ---
pd 4
EOF
EXPECT=<<EOF
mov eax, dword [eax + foo.b]
mov dword [ecx + foo.b], edx
lea edx, [eax + foo.c]
cmp dword [eax + foo.c], 0
---
            0x00000000      8b4004         mov   eax, dword [eax + foo.b]
            0x00000003      895104         mov   dword [ecx + foo.b], edx
            0x00000006      8d5008         lea   edx, [eax + foo.c]
            0x00000009      83780800       cmp   dword [eax + foo.c], 0
EOF
RUN

NAME=struct offset propagate via type of global variable
FILE==
CMDS=<<EOF
e asm.arch=x86
e asm.bytes=true
e asm.bits=64
e asm.comments=false
td "struct bar {int a ; int b; int c;}"
wx 48C7C058190000488B5004488B4808483B500448BBEFBEADDE00000000488958089090C3
af
avga bla "struct bar" @ 0x1958
aat
pdf~bar.
EOF
EXPECT=<<EOF
|           0x00000007      488b5004       mov   rdx, qword [rax + bar.b]
|           0x0000000b      488b4808       mov   rcx, qword [rax + bar.c]
|           0x0000000f      483b5004       cmp   rdx, qword [rax + bar.b]
|           0x0000001d      48895808       mov   qword [rax + bar.c], rbx
EOF
RUN

NAME=aat with single struct
FILE==
CMDS=<<EOF
e asm.bytes=true
e asm.arch=x86
e asm.bits=64
e asm.comments=false
td "struct bar {int a ; int b; int c;}"
wx 48C7C058190000488B5004488B4808483B500448BBEFBEADDE00000000488958089090C3
avga bla "struct bar" @ 0x1958
af
aat @ fcn.00000000
echo
pdf~bar.
EOF
EXPECT=<<EOF

|           0x00000007      488b5004       mov   rdx, qword [rax + bar.b]
|           0x0000000b      488b4808       mov   rcx, qword [rax + bar.c]
|           0x0000000f      483b5004       cmp   rdx, qword [rax + bar.b]
|           0x0000001d      48895808       mov   qword [rax + bar.c], rbx
EOF
RUN

NAME=aat with multiple struct
FILE==
CMDS=<<EOF
e asm.arch=x86
e asm.bytes=true
e asm.bits=64
e asm.comments=false
e asm.flags=false
td "struct bar {int x; int y; int z;};"
td "struct foo {int a; int b; int c;};"
wx 48C7C000010000488B5008488B480448C7C000020000488B5008488B48049090C3
avga bla "struct bar" @ 0x200
avga boo "struct foo" @ 0x100
af
aat
pdf
EOF
EXPECT=<<EOF
/ fcn.00000000();
|           0x00000000      48c7c0000100.  mov   rax, 0x100
|           0x00000007      488b5008       mov   rdx, qword [rax + foo.c]
|           0x0000000b      488b4804       mov   rcx, qword [rax + foo.b]
|           0x0000000f      48c7c0000200.  mov   rax, 0x200
|           0x00000016      488b5008       mov   rdx, qword [rax + bar.z]
|           0x0000001a      488b4804       mov   rcx, qword [rax + bar.y]
|           0x0000001e      90             nop
|           0x0000001f      90             nop
\           0x00000020      c3             ret
EOF
RUN

NAME=Comments and var in struct offset propagation
FILE=bins/elf/struct_sample
CMDS=<<EOF
e asm.bytes=true
aa
s main
td "struct Books {char  title[50];char  author[50]; char  subject[100];};"
avga b "struct Books" @ 0x00177f18
aat main
pdf~Books
EOF
EXPECT=<<EOF
|           ; var struct Books Books @ stack - 0xe8
|           0x00000684      488d8520ffff.  lea   rax, [Books.title]
|           0x00000695      488910         mov   qword [rax], rdx      ; Books.title[0]
|           0x00000698      488d8520ffff.  lea   rax, [Books.title]
|           0x000006ad      488908         mov   qword [rax], rcx      ; Books.author[0]
|           0x000006b0      488d8520ffff.  lea   rax, [Books.title]
|           0x000006c5      488930         mov   qword [rax], rsi      ; Books.subject[0]
|           0x000006c8      66c740086700   mov   word [rax + Books.subject[8]], 0x67 ; 'g'
|           0x000006d5      b800000000     mov   eax, 0                ; Books.subject[0]
EOF
RUN

NAME=Global variable with ahr (return value hint)
FILE=bins/elf/struct_2
CMDS=<<EOF
e asm.bytes=true
aa
td "struct Test { int a; int  b; char *c;};"
s main
ahr 0x00000597 @ 0x00000592
avga t "struct Test" @ 0x00002020
aat main
s 0x000005a8
pd 3
EOF
EXPECT=<<EOF
|           0x000005a8      c70206000000   mov   dword [edx], 6        ; Test.a
|           0x000005ae      8b55f4         mov   edx, dword [Test.a]   ; Test.a
|           0x000005b1      c74204070000.  mov   dword [edx + Test.b], 7
EOF
RUN

NAME=Basic union test
FILE=bins/elf/union_sample
CMDS=<<EOF
e asm.bytes=true
aa
td "union Books {char  title[50];char  author[50]; char  subject[100];};"
tu Books
s main
afvt var_78h "union Books"
afvn books var_78h
afvl~Books
s 0x000006d2
pd 1
EOF
EXPECT=<<EOF
pf "0[50]c[50]c[100]c title author subject"
var union Books books @ stack - 0x78
|           0x000006d2      488d4590       lea   rax, [books.title]
EOF
RUN

NAME=ts and tu with multiple declarators
FILE==
CMDS=<<EOF
td "struct bla {int foo,bar; void *b};"
td "union foo {float a,b; int c,d;};"
td "typedef struct {char *a; void *b;} ts, *pts;"
tsc bla
tuc foo
ttc ts
tsc "anonymous struct 0"
ttc pts
EOF
EXPECT=<<EOF
union foo {
	float a;
	float b;
	int c;
	int d;
};
typedef struct anonymous struct 0 ts;
struct anonymous struct 0 {
	char *a;
	void *b;
};
typedef struct anonymous struct 0 * pts;
EOF
RUN

NAME=ts function pointer test
FILE==
CMDS=<<EOF
e asm.bits=64
ws hello @ 0xc
td "struct foo {int x; int (*fp)(int a , int b ); char *b;};"
ts foo
tcd foo
tsc foo
.ts foo
td "struct boo {int x; int (***ffp)(int a , int b ); char *b;};"
ts boo
tcd boo
tsc boo
.ts boo
# See https://github.com/rizinorg/rizin/issues/2190
#td "struct moo {wchar_t (*(*dunk)[])(int, const char*)} goo;"
#ts moo
#tcd moo
#tsc moo
EOF
EXPECT=<<EOF
pf "dpz x (fp)fp b"
struct foo { int x; int (*fp)(int a, int b); char *b; };
struct foo {
	int x;
	int (*fp)(int a, int b);
	char *b;
};
  x : 0x00000000 = 0
(fp)fp : 0x00000004 = (qword)0x0000000000000000
  b : 0x0000000c = "\x05hello"
pf "dpz x (ffp)ffp b"
struct boo { int x; int (***ffp)(int a, int b); char *b; };
struct boo {
	int x;
	int (***ffp)(int a, int b);
	char *b;
};
   x : 0x00000000 = 0
(ffp)ffp : 0x00000004 = (qword)0x0000000000000000
   b : 0x0000000c = "\x05hello"
EOF
RUN

NAME=ts general pointers test
FILE==
CMDS=<<EOF
td "struct normal {int a;char b;};"
td "struct pointer {char *y;struct normal *obj;};"
ts normal
ts pointer
EOF
EXPECT=<<EOF
pf "dc a b"
pf "z*? y (normal)obj"
EOF
RUN

NAME=tsc test
FILE==
CMDS=<<EOF
td "struct three_elements{int x; char y; float z;}"
tsc three_elements
EOF
EXPECT=<<EOF
struct three_elements {
	int x;
	char y;
	float z;
};
EOF
RUN

NAME=tsc with array
FILE==
CMDS=<<EOF
td "struct with_array{int x; char y[50]; float z;}"
tsc with_array
EOF
EXPECT=<<EOF
struct with_array {
	int x;
	char y[50];
	float z;
};
EOF
RUN

NAME=tsl test with pointers
FILE==
CMDS=<<EOF
e asm.arch=x86
e asm.bits=64
td "struct foo { void *v1; void *v2; };"
tsl foo
e asm.bits=32
td "struct foo { void *v1; void *v2; };"
tsl foo
e asm.bits=16
td "struct foo { void *v1; void *v2; };"
tsl foo
EOF
EXPECT=<<EOF
struct foo:
	v1: void * (size = 8, offset = 0)
	v2: void * (size = 8, offset = 8)
struct foo:
	v1: void * (size = 4, offset = 0)
	v2: void * (size = 4, offset = 4)
struct foo:
	v1: void * (size = 2, offset = 0)
	v2: void * (size = 2, offset = 2)
EOF
RUN

NAME=tec test
FILE==
CMDS=<<EOF
td "enum Foo {COW=1,BAR=2};"
tec Foo
EOF
EXPECT=<<EOF
enum Foo {
	COW = 0x1,
	BAR = 0x2
};
EOF
RUN

NAME=ted test
FILE==
CMDS=<<EOF
td "enum Foo {COW=1,BAR=2};"
ted Foo
EOF
EXPECT=<<EOF
enum Foo { COW = 0x1, BAR = 0x2 };
EOF
RUN

NAME=tuc test
FILE==
CMDS=<<EOF
td "union x{int x; int y; int z;}"
tuc x
EOF
EXPECT=<<EOF
union x {
	int x;
	int y;
	int z;
};
EOF
RUN

NAME=ttc test
FILE==
CMDS=<<EOF
td "typedef char FILE_NAME;"
ttc FILE_NAME
EOF
EXPECT=<<EOF
typedef char FILE_NAME;
EOF
RUN

NAME=tcd test
FILE==
CMDS=<<EOF
td "typedef char FILE_NAME;"
td "union xxx{int x; int y; int z;}"
td "enum Foo {COW=1,BAR=2};"
td "struct three_elements{int x; char y; float z;}"
tcd~FILE_NAME
tcd~xxx
tcd~three_elements
tcd~Foo
EOF
EXPECT=<<EOF
typedef char FILE_NAME;
union xxx { int x; int y; int z; };
struct three_elements { int x; char y; float z; };
enum Foo { COW = 0x1, BAR = 0x2 };
EOF
RUN

NAME=typedef struct
FILE==
CMDS=<<EOF
to bins/headers/12272.h
ts A
ts "anonymous struct 0"
ts "anonymous struct 1"
echo ----
tsc A
tsc "anonymous struct 0"
tsc "anonymous struct 1"
tsc O
echo ----
tt A
tt B
tt O
EOF
EXPECT=<<EOF
pf "f num"
pf "dF num num2"
pf "c ch"
----
struct A {
	float num;
};
struct anonymous struct 0 {
	int num;
	double num2;
};
struct anonymous struct 1 {
	char ch;
};
struct O {
	char *ptr;
};
----
B = struct anonymous struct 1
EOF
RUN

NAME=typedef struct double header
FILE==
CMDS=<<EOF
to bins/headers/hdr1.h
to bins/headers/hdr2.h
ts "anonymous struct 0"
ts "anonymous struct 1"
ts A
ts B
ttc A
ttc B
tsc "anonymous struct 0"
tsc "anonymous struct 1"
EOF
EXPECT=<<EOF
pf "f num"
pf "c ch"
pf "f num"
pf "c ch"
typedef struct anonymous struct 0 A;
typedef struct anonymous struct 1 B;
struct anonymous struct 0 {
	float num;
};
struct anonymous struct 1 {
	char ch;
};
EOF
RUN

NAME=Variable character array
FILE=bins/elf/ls
CMDS=<<EOF
aaa
s 0x4070
afvl
afvt var_70h "char [20]"
afvl
ar bp=0x98
afvd var_70h
EOF
EXPECT=<<EOF
var uint64_t var_80h @ stack - 0x80
var uint64_t var_71h @ stack - 0x71
var int64_t var_70h @ stack - 0x70
var char *var_60h @ stack - 0x60
var int64_t var_58h @ stack - 0x58
var int64_t var_56h @ stack - 0x56
var int64_t var_50h @ stack - 0x50
var int64_t var_43h @ stack - 0x43
var int64_t var_42h @ stack - 0x42
var int64_t var_41h @ stack - 0x41
var int64_t var_40h @ stack - 0x40
arg int64_t arg_5h @ stack + 0x5
arg int argc @ rdi
arg char **argv @ rsi
var uint64_t var_80h @ stack - 0x80
var uint64_t var_71h @ stack - 0x71
var char [20] var_70h @ stack - 0x70
var int64_t var_58h @ stack - 0x58
var int64_t var_56h @ stack - 0x56
var int64_t var_50h @ stack - 0x50
var int64_t var_43h @ stack - 0x43
var int64_t var_42h @ stack - 0x42
var int64_t var_41h @ stack - 0x41
var int64_t var_40h @ stack - 0x40
arg int64_t arg_5h @ stack + 0x5
arg int argc @ rdi
arg char **argv @ rsi
var var_70h = 0x00000028 = [ 'h', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '8', '.', '.', '.', '@', '.' ]
EOF
RUN

NAME=Backward param type propagation
FILE=bins/elf/back1
CMDS=<<EOF
aa
s main
aaft
afvl
EOF
EXPECT=<<EOF
var size_t size @ stack - 0x1c
var char *dest @ stack - 0x18
var const char *src @ stack - 0x10
EOF
RUN

NAME=Forward param type propagation
FILE=bins/elf/forward1
CMDS=<<EOF
aa
s main
aaft
afvl
EOF
EXPECT=<<EOF
var size_t size @ stack - 0x1c
var char *ptr @ stack - 0x18
var const char *src @ stack - 0x10
EOF
RUN

NAME=Propagation via value
FILE=bins/elf/follow_ptr
CMDS=<<EOF
aa
s main
aaft
afvl
EOF
EXPECT=<<EOF
var size_t var_24h @ stack - 0x24
var const char *var_20h @ stack - 0x20
var const char *s @ stack - 0x18
var const char *var_10h @ stack - 0x10
EOF
RUN

NAME=General type propagation
FILE=bins/elf/hello_world
CMDS=<<EOF
aa
s main
aaft
afvl
EOF
EXPECT=<<EOF
var size_t var_28h @ stack - 0x28
var size_t size @ stack - 0x24
var const char *src @ stack - 0x20
var const char *s2 @ stack - 0x18
var char *dest @ stack - 0x10
EOF
RUN

NAME=32-bit bin type propagation
FILE=bins/elf/hello_world32
CMDS=<<EOF
aa
s main
aaft
afvl
EOF
EXPECT=<<EOF
var const char *src @ stack - 0x24
var const char *s2 @ stack - 0x20
var size_t var_1ch @ stack - 0x1c
var size_t size @ stack - 0x18
var char *dest @ stack - 0x14
var int32_t var_10h @ stack - 0x10
arg int argc @ stack + 0x4
EOF
RUN

NAME=off-by-1 stack arg fix (#3835)
FILE=bins/elf/true32
CMDS=aa; pd 1 @ main
EXPECT=<<EOF
            ; DATA XREF from entry0 @ 0x8048e5b
            ;-- section..text:
/ int main(int argc, char **argv, char **envp);
|           ; var int32_t var_40h @ stack - 0x40
|           ; var int32_t var_24h @ stack - 0x24
|           ; var int32_t var_20h @ stack - 0x20
|           ; var int32_t var_1ch @ stack - 0x1c
|           ; var int32_t var_18h @ stack - 0x18
|           ; var int32_t var_14h @ stack - 0x14
|           ; arg int argc @ stack + 0x4
|           ; arg char **argv @ stack + 0x8
|           0x08048d60      push  ebp                                  ; [13] -r-x section size 9756 named .text
EOF
RUN

NAME=Register based var
FILE=bins/elf/arg
CMDS=<<EOF
aa
s sym.funcarg
afvr
EOF
EXPECT=<<EOF
arg int64_t arg4 @ rcx
arg int64_t arg1 @ rdi
arg int64_t arg3 @ rdx
arg int64_t arg2 @ rsi
EOF
RUN

NAME=Type propagation for reg based arg
FILE=bins/elf/arg
CMDS=<<EOF
aa
aaft
s sym.funcarg
afvr
EOF
EXPECT=<<EOF
arg size_t arg4 @ rcx
arg const char *arg1 @ rdi
arg int64_t arg3 @ rdx
arg const char *arg2 @ rsi
EOF
RUN

NAME=Caller to callee propagation (64 bits)
FILE=bins/elf/arg_down_prop
CMDS=<<EOF
e asm.lines=false
e asm.bytes=true
e asm.xrefs=false
aa
aaft
s sym.funcarg
pd 1
EOF
EXPECT=<<EOF
sym.funcarg(const char *arg1, uint64_t arg2);
; arg const char *arg1 @ rdi
; arg uint64_t arg2 @ rsi
; var uint64_t var_14h @ stack - 0x14
; var const char *var_10h @ stack - 0x10
0x0000068a      55             push  rbp
EOF
RUN

NAME=Caller to caller propagation (32 bits)
FILE=bins/elf/arg_down_32
CMDS=<<EOF
e asm.lines=false
e asm.bytes=true
e asm.xrefs=false
aa
aaft
s sym.funcarg
pd 1
EOF
EXPECT=<<EOF
sym.funcarg(const char *arg_4h, unsigned long arg_8h);
; var int32_t var_8h @ stack - 0x8
; arg const char *arg_4h @ stack + 0x4
; arg unsigned long arg_8h @ stack + 0x8
0x0000054d      55             push  ebp
EOF
RUN

NAME=Type Propagation
FILE=bins/pe/debugme.exe
BROKEN=1
CMDS=<<EOF
aaaa
pd 1 @ 0x00401792~?[n
pd 1 @ 0x00401796~?[c
pd 1 @ 0x0040179e~?[s
pd 1 @ 0x004017b1~?[n
pd 1 @ 0x004017b5~?[c
pd 1 @ 0x004017bd~?[s
pd 1 @ 0x0040186a~?[s2
pd 1 @ 0x0040186e~?[s1
pd 1 @ 0x0040152f~?[dwInitParam
pd 1 @ 0x00401537~?[lpDialogFunc
pd 1 @ 0x0040153f~?[hWndParent
pd 1 @ 0x00401547~?[lpTemplateName
pd 1 @ 0x00401554~?[hInstance
EOF
EXPECT=<<EOF
1
1
1
1
1
1
1
1
1
1
1
1
1
EOF
RUN

NAME=Double pointer test
FILE=bins/elf/double_ptr
CMDS=<<EOF
aa
aaft
s main
afvl~ptr
EOF
EXPECT=<<EOF
var char **ptr @ stack - 0x20
EOF
RUN

NAME=Signed and unsigned test
FILE=bins/elf/signed_test
CMDS=<<EOF
aa
aaft
s main
afvl~var_3ch
afvl~var_38h
afvl~var_30h
EOF
EXPECT=<<EOF
var int var_3ch @ stack - 0x3c
var int64_t var_38h @ stack - 0x38
var uint64_t var_30h @ stack - 0x30
EOF
RUN

NAME=flagspace analysis
FILE=bins/elf/flagspace
CMDS=<<EOF
aa
aaft
s main
afvl
EOF
EXPECT=<<EOF
var void *va_args @ stack - 0x3c
var uint64_t var_34h @ stack - 0x34
var FILE *stream @ stack - 0x30
var const char *s @ stack - 0x28
var const char *var_20h @ stack - 0x20
var const char *var_18h @ stack - 0x18
var int64_t canary @ stack - 0x10
EOF
RUN

NAME=aaft io.va side effect
FILE==
ARGS=-eio.va=0 -a x86 -b 64
CMDS=<<EOF
af
aaft
e io.va
EOF
EXPECT=<<EOF
false
EOF
RUN

NAME=bashbot test (x86_64)
FILE=bins/elf/bashbot.x86_64.O0.elf
CMDS=<<EOF
aa
aaft
s main
afvl
s sym.processCmd
afvl
EOF
EXPECT=<<EOF
var char **var_14e8h @ stack - 0x14e8
var int var_14dch @ stack - 0x14dc
var int *wstatus @ stack - 0x14d4
var int64_t var_14cch @ stack - 0x14cc
var int64_t var_14c8h @ stack - 0x14c8
var int64_t var_14c4h @ stack - 0x14c4
var uint64_t pid @ stack - 0x14c0
var uint64_t var_14bch @ stack - 0x14bc
var uint64_t var_14b8h @ stack - 0x14b8
var int64_t var_14b4h @ stack - 0x14b4
var const char *var_14b0h @ stack - 0x14b0
var const char *s @ stack - 0x14a8
var int64_t var_14a0h @ stack - 0x14a0
var char *src @ stack - 0x1498
var const char *v2 @ stack - 0x1490
var const char *var_1488h @ stack - 0x1488
var void *var_1480h @ stack - 0x1480
var char *dest @ stack - 0x1478
var void *var_1428h @ stack - 0x1428
var const char *s1 @ stack - 0x1028
var int64_t var_20h @ stack - 0x20
arg int argc @ rdi
arg char **argv @ rsi
var char *str @ stack - 0xb8
var int64_t var_ach @ stack - 0xac
var int64_t var_a8h @ stack - 0xa8
var uint64_t var_a4h @ stack - 0xa4
var int var_a0h @ stack - 0xa0
var int var_9ch @ stack - 0x9c
var int var_98h @ stack - 0x98
var int var_94h @ stack - 0x94
var int var_90h @ stack - 0x90
var int var_8ch @ stack - 0x8c
var int var_88h @ stack - 0x88
var int var_84h @ stack - 0x84
var int64_t var_80h @ stack - 0x80
var int var_7ch @ stack - 0x7c
var int var_78h @ stack - 0x78
var int var_74h @ stack - 0x74
var int64_t var_70h @ stack - 0x70
var int64_t var_6ch @ stack - 0x6c
var char *var_68h @ stack - 0x68
var char *var_60h @ stack - 0x60
var char *var_58h @ stack - 0x58
var char *var_50h @ stack - 0x50
var uint64_t var_48h @ stack - 0x48
var const char *s1 @ stack - 0x40
var const char *s @ stack - 0x38
var const char *var_30h @ stack - 0x30
var const char *var_28h @ stack - 0x28
var int64_t var_20h @ stack - 0x20
var int64_t var_10h @ stack - 0x10
arg int64_t arg1 @ rdi
arg char *arg2 @ rsi
EOF
RUN

NAME=bashbot test (arm 32-bits)
FILE=bins/elf/bashbot.arm.gcc.O0.elf
CMDS=<<EOF
s main
af
aaft
afvl
EOF
EXPECT=<<EOF
var int32_t var_1460h @ stack - 0x1460
var void *var_1444h @ stack - 0x1444
var const char *s1 @ stack - 0x1044
var int *wstatus @ stack - 0x50
var int32_t var_4ch @ stack - 0x4c
var const char *var_48h @ stack - 0x48
var int32_t var_44h @ stack - 0x44
var int32_t var_40h @ stack - 0x40
var int32_t var_3ch @ stack - 0x3c
var pid_t pid @ stack - 0x38
var const char *v2 @ stack - 0x34
var int32_t var_30h @ stack - 0x30
var const char *src @ stack - 0x2c
var int32_t var_28h @ stack - 0x28
var int32_t var_24h @ stack - 0x24
var const char *s @ stack - 0x20
var const char *var_1ch @ stack - 0x1c
var int32_t var_18h @ stack - 0x18
var int32_t var_14h @ stack - 0x14
var const char *option @ stack - 0x10
arg int argc @ r0
arg char **argv @ r1
EOF
RUN

NAME=format string parse
FILE=bins/elf/format
CMDS=<<EOF
aa
aaft
s main
afvl
EOF
EXPECT=<<EOF
var int64_t var_2dh @ stack - 0x2d
var int64_t var_2ch @ stack - 0x2c
var unsigned int var_28h @ stack - 0x28
var int64_t var_24h @ stack - 0x24
var const char *var_20h @ stack - 0x20
var long int var_18h @ stack - 0x18
var const char *var_10h @ stack - 0x10
EOF
RUN

NAME=local to register var type propagation
FILE=bins/elf/l2rbin
CMDS=<<EOF
aa
aaft
s main
afvl
EOF
EXPECT=<<EOF
var char **var_30h @ stack - 0x30
var char **var_28h @ stack - 0x28
var int var_1ch @ stack - 0x1c
var void *var_18h @ stack - 0x18
var int var_ch @ stack - 0xc
arg int argc @ rdi
arg char **envp @ rdx
arg char **argv @ rsi
EOF
RUN

NAME=constrained type
FILE=bins/elf/constr_type
CMDS=<<EOF
e analysis.types.constraint=true
aaa
s sym.single_cond
pd 1~ch
s sym.range_small
pd 1~1ch
s sym.range_high
pd 1~ch
s sym.range_or
pd 1~ch
EOF
EXPECT=<<EOF
|           ; var int64_t var_ch  { > 0xa} @ stack - 0xc
|           ; var int64_t var_1ch  { > 0x0 && <= 0x9} @ stack - 0x1c
|           ; var int64_t var_ch  { > 0x64 && <= 0xc7} @ stack - 0xc
|           ; var int64_t var_ch  { > 0xff && <= 0x12b || > 0x14 && <= 0x31 || > 0x6f && <= 0xdd} @ stack - 0xc
EOF
RUN

NAME=mov str
FILE=bins/elf/movstr
CMDS=<<EOF
aaa
s main
afvl~var_28h
EOF
EXPECT=<<EOF
var const char *var_28h @ stack - 0x28
EOF
RUN

NAME=ret type pointer
FILE=bins/elf/tie-test
CMDS=<<EOF
aaa
s sym.foo
afvl~var_28h
EOF
EXPECT=<<EOF
var size_t *var_28h @ stack - 0x28
EOF
RUN

NAME=types size
FILE==
CMDS=<<EOF
td "struct s1 { int a; int size; int b; };"
ts s1
EOF
EXPECT=<<EOF
pf "ddd a size b"
EOF
RUN

NAME=types afs [before]
FILE=bins/elf/hello_world
CMDS=<<EOF
s main
af
tf main
EOF
EXPECT=<<EOF
int main(int argc, char **argv, char **envp);
EOF
RUN

NAME=types afs [after]
FILE=bins/elf/hello_world
CMDS=<<EOF
s main
af
afs "int main(int argc);"
tf main
EOF
EXPECT=<<EOF
int main(int argc);
EOF
RUN

NAME=afs without type
FILE=bins/elf/analysis/pid_stripped
CMDS=<<EOF
s 0x4e2420
af
afs
afs "void no_type(int a, char **b);"
afs
afs "char type(int a, char **b);"
afs
EOF
EXPECT=<<EOF
void fcn.004e2420(int64_t arg1, int64_t arg2, int64_t arg3, int64_t arg4, int64_t arg5, int64_t arg6, int64_t arg_8h);
void no_type(int a, char **b);
char type(int a, char **b);
EOF
RUN

NAME=afs fcnname with dots
FILE=bins/elf/hello_world
CMDS=<<EOF
af
afs
afs "void foo.bar();"
afs
afs "char foo.bar(int a, ...);"
afs
EOF
EXPECT=<<EOF
void entry0(int64_t arg3);
void foo.bar();
char foo.bar(int a);
EOF
RUN

NAME=afs sym.imp.*
FILE=bins/elf/hello_world
CMDS=<<EOF
s sym.imp.strlen
af
afs
EOF
EXPECT=<<EOF
size_t strlen(const char *s);
EOF
RUN

NAME=afs fastcall
FILE=bins/elf/analysis/fast
CMDS=<<EOF
s sym.fastcaslled
af
afc fastcall
afs "int fastcalled(int sarg0, int sarg1, int sarg2, int sarg3)"
afs
afvl
afi~name,convention
EOF
EXPECT=<<EOF
int fastcalled(int sarg0, int sarg1, int sarg2, int sarg3);
var int32_t var_24h @ stack - 0x24
var int32_t var_20h @ stack - 0x20
var int32_t var_14h @ stack - 0x14
var int32_t var_10h @ stack - 0x10
arg int sarg2 @ stack + 0x4
arg int sarg3 @ stack + 0x8
arg int sarg0 @ ecx
arg int sarg1 @ edx
name: fastcalled
call-convention: fastcall
EOF
RUN

NAME=td crash
FILE==
CMDS=<<EOF
td "struct;"
td "stract"
td "struct crash __attribute__((packed)) { };"
EOF
EXPECT_ERR=<<EOF
ERROR: core: Unsupported type definition: struct;;
ERROR: core: Unsupported type definition: stract;
ERROR: core: Unsupported type definition: { }
Unsupported type definition: ;;
EOF
RUN

NAME=tn common
FILE=bins/pe/pe.exe
CMDS=<<EOF
tn
echo ---
tn- FatalExit
tn
echo ---
tn-*
tn
EOF
EXPECT=<<EOF
FreeLibraryAndExitThread
FatalExit
ExitProcess
ExitThread
RtlRaiseException
RaiseException
---
FreeLibraryAndExitThread
ExitProcess
ExitThread
RtlRaiseException
RaiseException
---
EOF
RUN

NAME=td union
FILE==
CMDS=<<EOF
td "union foo {int a;char b;}"
t* foo
tu foo
t foo
EOF
EXPECT=<<EOF
pfn "foo" "0dc a b"
pf "0dc a b"
pf "0dc a b"
EOF
RUN

NAME=td uint64_t
FILE==
CMDS=<<EOF
wx 0xa00f
wx 0x401f @ 0x4
wx 0800000000000080 @ 0x8
td "struct foo {int a; int b; uint64_t c;};"
avga goo "struct foo" @ 0x0
pd 1
EOF
EXPECT=<<EOF
(foo goo)
 a : 0x00000000 = 4000
 b : 0x00000004 = 8000
 c : 0x00000008 = (qword)0x8000000000000008
EOF
RUN

NAME=td empty struct
FILE==
CMDS=<<EOF
wx 0xa00f
wx 0x401f @ 0x4
wx 0800000000000080 @ 0x8
td "struct foo {};"
avga goo "struct foo" @ 0x0
pd 1
EOF
EXPECT=<<EOF
(foo goo)
EOF
RUN

NAME=type xrefs
FILE=bins/elf/ls.odd
CMDS=<<EOF
aaaa
txf main
echo =
txf fcn.00011b90
echo =
tx size_t
echo =
tx "size_t *"
EOF
EXPECT=<<EOF
int64_t
const char *
uint64_t
int
char **
=
int64_t
const char *
uint64_t
const void *
size_t
mbstate_t *
wint_t
size_t *
=
fcn.00011b90
fcn.0000e780
fcn.0000c0f0
=
fcn.00011b90
fcn.00014d50
EOF
RUN

NAME=aht aligned
FILE==
BROKEN=1
CMDS=<<EOF
e asm.arch=x86
e asm.bytes=true
e asm.bits=64
td "struct foo {char gap;int bar __attribute__((__aligned__(4)));};"
td "struct foo2 {char gap[1];int bar __attribute__((__aligned__(4)));};"
td "struct foo3 {char gap[3];int bar __attribute__((__aligned__(4)));};"
td "struct foo4 {char gap[4];int bar;};"
td "struct foo5 {int gap;int bar;};"
ahts 4 ~foo
echo =
wx c7400400000000
aht foo.bar
pd 1
EOF
EXPECT=<<EOF
foo.bar
foo2.bar
foo3.bar
foo4.bar
foo5.bar
=
            0x00000000      c74004000000.  mov   dword [rax + foo.bar], 0
EOF
RUN

NAME=ahts nested
BROKEN=1
FILE==
CMDS=<<EOF
td "struct foo {int bar;int cow;};"
td "struct spam {int ham;struct foo _foo;int eggs;};"
ahts 8 ~spam
EOF
EXPECT=<<EOF
spam._foo.cow
EOF
RUN


NAME=windows builtin types and callables
FILE=--
ARGS=-a x86 -b 64 -k windows
CMDS=<<EOF
t~BITMAPINFO
t~HCALL
t~LANGID
t~PPROCESS_MEMORY_COUNTERS
t~LPCWSTR
t~LPACCEL
t~PDWORD64
t~int16_t
echo ------------------------------------------
tf
EOF
EXPECT=<<EOF
LPBITMAPINFO
BITMAPINFO
PBITMAPINFO
PBITMAPINFOHEADER
tagBITMAPINFOHEADER
BITMAPINFOHEADER
tagBITMAPINFO
HCALL
PFINDFILEINPATHCALLBACK
PFINDFILEINPATHCALLBACKW
LANGID
PPROCESS_MEMORY_COUNTERS
LPCWSTR
LPACCEL
PDWORD64
uint16_t
int16_t
------------------------------------------
BOOL PlayMetaFile(HDC hdc, HMETAFILE hmf);
void PathRemoveBlanksW(LPWSTR pszPath);
INT ShellAboutA(HWND hWnd, LPCSTR szApp, LPCSTR szOtherStuff, HICON hIcon);
PCHAR ldap_next_attribute(LDAP *ld, LDAPMessage *entry, BerElement *ptr);
DWORD SearchPathA(LPCSTR lpPath, LPCSTR lpFileName, LPCSTR lpExtension, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart);
DWORD UnDecorateSymbolNameW(PCWSTR name, PWSTR outputString, DWORD maxStringLength, DWORD flags);
int StrCmpW(PCWSTR psz1, PCWSTR psz2);
HRESULT SafeArrayDestroyDescriptor(unknown_t *psa);
DWORD SearchPathW(LPCWSTR lpPath, LPCWSTR lpFileName, LPCWSTR lpExtension, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart);
int setvbuf(FILE *stream, char *buf, int mode, size_t size);
BOOL SymMatchFileNameW(PCWSTR FileName, PCWSTR Match, PWSTR *FileNameStop, PWSTR *MatchStop);
SIZE_T VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength);
BOOL SetProcessAffinityMask(HANDLE hProcess, DWORD_PTR dwProcessAffinityMask);
BOOL EndDialog(HWND hDlg, INT_PTR nResult);
HRESULT PathCchFindExtension(PCWSTR pszPath, size_t cchPath, PCWSTR *ppszExt);
BOOL CreateHardLinkTransactedW(LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes, HANDLE hTransaction);
void PathRemoveBlanksA(LPSTR pszPath);
BOOL CryptDuplicateKey(HCRYPTKEY hKey, DWORD *pdwReserved, DWORD dwFlags, HCRYPTKEY *phKey);
DWORD GetClipboardSequenceNumber();
HFONT CreateFontIndirectW();
HRESULT SHGetSpecialFolderLocation(HWND hwndOwner, unknown_t nFolder, LPITEMIDLIST *ppidl);
HMENU GetMenu(HWND hWnd);
HRESULT VarBstrCmp(BSTR bstrLeft, BSTR bstrRight, LCID lcid, ULONG dwFlags);
BOOL CreateHardLinkTransactedA(LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes, HANDLE hTransaction);
HFONT CreateFontIndirectA();
SIZE_T HeapCompact(HANDLE hHeap, DWORD dwFlags);
BOOL AdjustWindowRect(LPRECT lpRect, DWORD dwStyle, BOOL bMenu);
DWORD GetWindowContextHelpId(HWND ARG_0);
INT WSCInstallNameSpace(LPWSTR lpszIdentifier, LPWSTR lpszPathName, DWORD dwNameSpace, DWORD dwVersion, LPGUID lpProviderId);
int iswgraph(wint_t wc);
HKL LoadKeyboardLayoutW(LPCWSTR pwszKLID, UINT Flags);
CONFIGRET CM_Get_First_Log_Conf(unknown_t plcLogConf, DEVINST dnDevInst, ULONG ulFlags);
BOOL AddAce(PACL pAcl, DWORD dwAceRevision, DWORD dwStartingAceIndex, LPVOID pAceList, DWORD nAceListLength);
BOOL UnionRect(LPRECT lprcDst, RECT *lprcSrc1, RECT *lprcSrc2);
CONFIGRET CM_Free_Res_Des(PRES_DES prdResDes, RES_DES rdResDes, ULONG ulFlags);
CONFIGRET CM_Locate_DevNode_ExA(unknown_t pdnDevInst, DEVINSTID_A pDeviceID, ULONG ulFlags, HMACHINE hMachine);
DWORD WinHttpWebSocketClose(HINTERNET hWebSocket, USHORT usStatus, PVOID pvReason, DWORD dwReasonLength);
ULONG CreateTraceInstanceId(HANDLE RegHandle, PEVENT_INSTANCE_INFO InstInfo);
BOOL ShutdownBlockReasonQuery(HWND hWnd, LPWSTR pwszBuff, DWORD *pcchBuff);
DWORD CertGetNameStringA(PCCERT_CONTEXT pCertContext, DWORD dwType, DWORD dwFlags, void *pvTypePara, LPSTR pszNameString, DWORD cchNameString);
BOOL InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags, PBOOL fPending, LPVOID *lpContext);
CONFIGRET CM_Locate_DevNode_ExW(unknown_t pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags, HMACHINE hMachine);
HKL LoadKeyboardLayoutA(LPCSTR pwszKLID, UINT Flags);
BOOL CredReadDomainCredentialsW(PCREDENTIAL_TARGET_INFORMATIONW TargetInfo, DWORD Flags, DWORD *Count, PCREDENTIALW **Credential);
HRESULT VarI4FromCy(unknown_t cyIn, LONG *plOut);
BOOL GetConsoleScreenBufferInfoEx(HANDLE hConsoleOutput, PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx);
LPVOID CoTaskMemAlloc(SIZE_T cb);
BOOLEAN RtlAddFunctionTable(PRUNTIME_FUNCTION FunctionTable, ULONG EntryCount, ULONG_PTR BaseAddress);
int iswdigit(wint_t wc);
void bzero(void *s, size_t n);
HRESULT VarI2FromDisp(unknown_t *pdispIn, LCID lcid, SHORT *psOut);
BOOL MakeDragList(HWND hLB);
VOID DisassociateCurrentThreadFromCallback(PTP_CALLBACK_INSTANCE pci);
BOOL SymGetSymPrev64(HANDLE hProcess, PIMAGEHLP_SYMBOL64 Symbol);
HWND ChildWindowFromPoint(HWND hWndParent, POINT Point);
DWORD CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType, DWORD dwFlags, void *pvTypePara, LPWSTR pszNameString, DWORD cchNameString);
BOOL FindVolumeMountPointClose(HANDLE hFindVolumeMountPoint);
long labs(long j);
BOOL CredReadDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInfo, DWORD Flags, DWORD *Count, PCREDENTIALA **Credential);
ULONG ldap_unbind_s(LDAP *ld);
BOOL TranslateCharsetInfo(DWORD *lpSrc, unknown_t lpCs, unknown_t dwFlags);
BOOL CloseFigure();
DWORD CredUIPromptForCredentialsA(PCREDUI_INFOA pUiInfo, PCSTR pszTargetName, PCtxtHandle pContext, DWORD dwAuthError, PSTR pszUserName, ULONG ulUserNameBufferSize, PSTR pszPassword, ULONG ulPasswordBufferSize, BOOL *save, DWORD dwFlags);
BOOL SetWindowPos(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags);
CONFIGRET CM_Add_Empty_Log_Conf(unknown_t plcLogConf, DEVINST dnDevInst, unknown_t Priority, ULONG ulFlags);
LANGID GetUserDefaultUILanguage();
CONFIGRET CM_Set_Class_Property_ExW(LPCGUID ClassGUID, unknown_t *PropertyKey, unknown_t PropertyType, PBYTE PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine);
BOOL FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData);
int DeviceCapabilitiesA(LPSTR pszPrinterName, LPSTR pszPortName, unknown_t capabilities, LPSTR pszOutput, unknown_t *pDevMode);
DWORD CredUIPromptForCredentialsW(PCREDUI_INFOW pUiInfo, PCWSTR pszTargetName, PCtxtHandle pContext, DWORD dwAuthError, PWSTR pszUserName, ULONG ulUserNameBufferSize, PWSTR pszPassword, ULONG ulPasswordBufferSize, BOOL *save, DWORD dwFlags);
DWORD CheckForHiberboot(PBOOLEAN pHiberboot, BOOLEAN bClearFlag);
char * setlocale(int category, const char *locale);
HRESULT SaveCompleted();
HRESULT IStream_Read(struct IStream *pstm, void *pv, ULONG cb);
BOOL GetRawPointerDeviceData(UINT32 pointerId, UINT32 historyCount, UINT32 propertiesCount, unknown_t *pProperties, LONG *pValues);
BOOL WriteConsoleOutputCharacterA(HANDLE hConsoleOutput, LPCSTR lpCharacter, DWORD nLength, COORD dwWriteCoord, LPDWORD lpNumberOfCharsWritten);
BOOL WPUCloseEvent(WSAEVENT hEvent, LPINT lpErrno);
BOOL FlatSB_SetScrollProp(HWND ARG_0, UINT index, INT_PTR newValue, BOOL ARG_3);
SECURITY_STATUS NCryptFinalizeKey(NCRYPT_KEY_HANDLE hKey, DWORD dwFlags);
BOOL CryptExportPKCS8(HCRYPTPROV hCryptProv, DWORD dwKeySpec, LPSTR pszPrivateKeyObjId, DWORD dwFlags, void *pvAuxInfo, BYTE *pbPrivateKeyBlob, DWORD *pcbPrivateKeyBlob);
BOOL Shell_NotifyIconA(DWORD dwMessage, PNOTIFYICONDATAA lpData);
BOOL WinHttpQueryDataAvailable(HINTERNET hRequest, LPDWORD lpdwNumberOfBytesAvailable);
BOOL SymSetSearchPath(HANDLE hProcess, PCSTR SearchPath);
int DeviceCapabilitiesW(LPWSTR pszPrinterName, LPWSTR pszPortName, unknown_t capabilities, LPWSTR pszOutput, unknown_t *pDevMode);
BOOL SymSetScopeFromInlineContext(HANDLE hProcess, ULONG64 Address, ULONG InlineContext);
INT ldap_create_vlv_controlA(PLDAP ExternalHandle, PLDAPVLVInfo VlvInfo, UCHAR IsCritical, PLDAPControlA *Control);
VOID OutputDebugStringW(LPCWSTR lpOutputString);
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
BOOL FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData);
long SetICMMode(HDC hDC, unknown_t iEnableICM);
ULONG ldap_add_ext_s(LDAP *ld, const PSTR dn, unknown_t **attrs, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
BOOL Shell_NotifyIconW(DWORD dwMessage, PNOTIFYICONDATAW lpData);
HRESULT IUnknown_GetWindow(IUnknown *punk, HWND *phwnd);
BOOL WriteConsoleOutputCharacterW(HANDLE hConsoleOutput, LPCWSTR lpCharacter, DWORD nLength, COORD dwWriteCoord, LPDWORD lpNumberOfCharsWritten);
INT ldap_create_vlv_controlW(PLDAP ExternalHandle, PLDAPVLVInfo VlvInfo, UCHAR IsCritical, PLDAPControlW *Control);
int vsscanf(const char *s, const char *format, va_list arg);
VOID OutputDebugStringA(LPCSTR lpOutputString);
DWORD CreateTapePartition(HANDLE hDevice, DWORD dwPartitionMethod, DWORD dwCount, DWORD dwSize);
UINT RegisterWindowMessageA(LPCSTR lpString);
BOOL EnumDisplayMonitors(HDC hdc, LPCRECT lprcClip, MONITORENUMPROC lpfnEnum, LPARAM dwData);
CONFIGRET CM_Enumerate_Classes_Ex(ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags, HMACHINE hMachine);
VOID InitializeSListHead(PSLIST_HEADER ListHead);
HRESULT VarI1FromR8(DOUBLE dblIn, CHAR *pcOut);
int SHUnicodeToUnicode(PCWSTR pwzSrc, PWSTR pwzDst, int cwchBuf);
BOOL PaintRgn(HDC hdc, HRGN HRGN);
ULONG_PTR GetClassLongPtrA(HWND hWnd, int nIndex);
BOOL DeleteMenu(HMENU hMenu, UINT uPosition, UINT uFlags);
HRESULT VarI1FromR4(FLOAT fltIn, CHAR *pcOut);
long long llabs(long long j);
double atan(double x);
HRESULT Shell_NotifyIconGetRect(unknown_t *identifier, RECT *iconLocation);
div_t div(int numer, int denom);
UINT RegisterWindowMessageW(LPCWSTR lpString);
long long strtoull(const char *str, char **endptr, int base);
HRESULT CreateDataCache(LPUNKNOWN pUnkOuter, unknown_t rclsid, REFIID iid, LPVOID *ppv);
char * nl_langinfo_l(nl_item item, locale_t locale);
PCCRL_CONTEXT CertCreateCRLContext(DWORD dwCertEncodingType, BYTE *pbCrlEncoded, DWORD cbCrlEncoded);
char * strpbrk(const char *s1, const char *s2);
UINT SetSystemPaletteUse(HDC hdc, unknown_t uUsage);
HRESULT VarI4FromDate(unknown_t dateIn, LONG *plOut);
HRESULT VarAdd(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
DWORD WinHttpIsHostInProxyBypassList(unknown_t *pProxyInfo, PCWSTR pwszHost, unknown_t tScheme, INTERNET_PORT nPort, BOOL *pfIsInBypassList);
BOOL GetDisplayAutoRotationPreferences(ORIENTATION_PREFERENCE *pOrientation);
BOOL DeleteVolumeMountPointW(LPCWSTR lpszVolumeMountPoint);
HRESULT UnregisterScaleChangeEvent(DWORD_PTR dwCookie);
BOOL DeleteTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent);
LONG GetWindowLongW(HWND hWnd, int nIndex);
void qsort(void *base, size_t nmemb, size_t size, void *compar);
HWND SetActiveWindow(HWND hWnd);
ULONG_PTR GetClassLongPtrW(HWND hWnd, int nIndex);
NTSTATUS BCryptConfigureContext(ULONG dwTable, LPCWSTR pszContext, PCRYPT_CONTEXT_CONFIG pConfig);
BOOL CreateUmsCompletionList(PUMS_COMPLETION_LIST *UmsCompletionList);
UINT GetProfileIntA(LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault);
HRESULT VarUI2FromCy(unknown_t cyIn, USHORT *puiOut);
BOOL SetConsoleCursorInfo(HANDLE hConsoleOutput, unknown_t *lpConsoleCursorInfo);
BOOL SetConsoleScreenBufferSize(HANDLE hConsoleOutput, COORD dwSize);
BOOL DeleteVolumeMountPointA(LPCSTR lpszVolumeMountPoint);
LONG GetWindowLongA(HWND hWnd, int nIndex);
HRESULT UrlCanonicalizeW(PCWSTR pszUrl, PWSTR pszCanonicalized, DWORD *pcchCanonicalized, DWORD dwFlags);
LPSTR lstrcatA(LPSTR lpString1, LPCSTR lpString2);
BOOL PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt);
BOOL CloseTouchInputHandle(HTOUCHINPUT hTouchInput);
NTSTATUS BCryptDestroyKey(BCRYPT_KEY_HANDLE hKey);
BOOL CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags);
BOOL SetCommBreak(HANDLE hFile);
UINT GetProfileIntW(LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault);
DWORD CertEnumCRLContextProperties(PCCRL_CONTEXT pCrlContext, DWORD dwPropId);
BOOL CloseWindow(HWND hWnd);
SECURITY_STATUS NCryptSetProperty(NCRYPT_HANDLE hObject, LPCWSTR pszProperty, PBYTE pbInput, DWORD cbInput, DWORD dwFlags);
BOOL SystemTimeToTzSpecificLocalTime(unknown_t *lpTimeZoneInformation, SYSTEMTIME *lpUniversalTime, LPSYSTEMTIME lpLocalTime);
HRESULT UrlCanonicalizeA(PCSTR pszUrl, PSTR pszCanonicalized, DWORD *pcchCanonicalized, DWORD dwFlags);
CONFIGRET CM_Free_Log_Conf(unknown_t lcLogConfToBeFreed, ULONG ulFlags);
SOCKET WPUCreateSocketHandle(DWORD dwCatalogEntryId, DWORD_PTR dwContext, LPINT lpErrno);
LPWSTR lstrcatW(LPWSTR lpString1, LPCWSTR lpString2);
int swscanf(wchar_t *s, wchar_t *format);
BOOL DlgDirSelectExA(HWND hwndDlg, LPSTR lpString, int chCount, int idListBox);
BOOL PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt);
int vsnprintf(char *s, size_t size, const char *format, va_list arg);
PWSTR StrPBrkW(PCWSTR psz, PCWSTR pszSet);
int GetMouseMovePointsEx(UINT cbSize, LPMOUSEMOVEPOINT lppt, LPMOUSEMOVEPOINT lpptBuf, int nBufPoints, DWORD resolution);
BOOL DrawCaption(HWND hwnd, HDC hdc, RECT *lprect, UINT flags);
HANDLE FindFirstFileNameW(LPCWSTR lpFileName, DWORD dwFlags, LPDWORD StringLength, PWSTR LinkName);
DWORD GetMenuContextHelpId(HMENU ARG_0);
BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount);
BOOL CryptExportPKCS8Ex(unknown_t *psExportParams, DWORD dwFlags, void *pvAuxInfo, BYTE *pbPrivateKeyBlob, DWORD *pcbPrivateKeyBlob);
HRESULT CoQueryClientBlanket(DWORD *pAuthnSvc, DWORD *pAuthzSvc, LPOLESTR *pServerPrincName, DWORD *pAuthnLevel, DWORD *pImpLevel, RPC_AUTHZ_HANDLE *pPrivs, DWORD *pCapabilities);
POWER_PLATFORM_ROLE PowerDeterminePlatformRoleEx(ULONG Version);
PSTR StrPBrkA(PCSTR psz, PCSTR pszSet);
uid_t getuid();
HRESULT RegisterActiveObject(IUnknown *punk, unknown_t rclsid, DWORD dwFlags, DWORD *pdwRegister);
HPALETTE SHCreateShellPalette(HDC hdc);
BOOL DlgDirSelectExW(HWND hwndDlg, LPWSTR lpString, int chCount, int idListBox);
void * fts_children_INODE64(void *ftsp, int opotions);
ULONG ldap_search_extW(LDAP *ld, PWSTR base, ULONG scope, PWSTR filter, PZPWSTR attrs, ULONG attrsonly, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, ULONG TimeLimit, ULONG SizeLimit, ULONG *MessageNumber);
BOOL GetAspectRatioFilterEx(HDC hdc, LPSIZE lpAspectRatio);
BOOL GetHandleInformation(HANDLE hObject, LPDWORD lpdwFlags);
BOOL CryptEnumProvidersA(DWORD dwIndex, DWORD *pdwReserved, DWORD dwFlags, DWORD *pdwProvType, LPSTR szProvName, DWORD *pcbProvName);
PWCHAR ldap_first_attributeW(LDAP *ld, LDAPMessage *entry, BerElement **ptr);
int __maskrune(long c, long f);
long _hwrite(HFILE hFile, LPCCH lpBuffer, long lBytes);
PWCHAR * ldap_get_valuesW(LDAP *ld, LDAPMessage *entry, PWSTR attr);
int getsockopt(SOCKET s, int level, int optname, char *optval, int *optlen);
VOID RtlUnwindEx(PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue, PCONTEXT ContextRecord, PVOID HistoryTable);
BOOL InitiateSystemShutdownExW(LPWSTR lpMachineName, LPWSTR lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown, DWORD dwReason);
CONFIGRET CM_Add_ID_ExA(DEVINST dnDevInst, PSTR pszID, ULONG ulFlags, HMACHINE hMachine);
int gethostname(char *name, int namelen);
CONFIGRET CM_Connect_MachineW(PCWSTR UNCServerName, PHMACHINE phMachine);
LSTATUS RegQueryValueExA(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
SECURITY_STATUS NCryptStreamUpdate(NCRYPT_STREAM_HANDLE hStream, BYTE *pbData, SIZE_T cbData, BOOL fFinal);
VOID SwitchToThisWindow(HWND hwnd, BOOL fUnknown);
ULONG ldap_search_extA(LDAP *ld, const PSTR base, ULONG scope, const PSTR filter, PZPSTR attrs, ULONG attrsonly, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG TimeLimit, ULONG SizeLimit, ULONG *MessageNumber);
DWORD CoBuildVersion();
LSTATUS SHEnumKeyExA(HKEY hkey, DWORD dwIndex, LPSTR pszName, LPDWORD pcchName);
UINT GetDriveTypeA(LPCSTR lpRootPathName);
int WSAPoll(LPWSAPOLLFD fdArray, ULONG fds, INT timeout);
DWORD SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod);
PCHAR ldap_first_attributeA(LDAP *ld, LDAPMessage *entry, BerElement **ptr);
ULONG ldap_modrdn_s(LDAP *ExternalHandle, const PSTR DistinguishedName, const PSTR NewDistinguishedName);
PCWSTR SymSrvStoreSupplementW(HANDLE hProcess, PCWSTR SymPath, PCWSTR Node, PCWSTR File, DWORD Flags);
PCHAR * ldap_get_valuesA(LDAP *ld, LDAPMessage *entry, const PSTR attr);
CONFIGRET CM_Connect_MachineA(PCSTR UNCServerName, PHMACHINE phMachine);
BOOL CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags);
BOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent, PACL *pSacl, LPBOOL lpbSaclDefaulted);
CONFIGRET CM_Add_ID_ExW(DEVINST dnDevInst, PWSTR pszID, ULONG ulFlags, HMACHINE hMachine);
LSTATUS SHEnumKeyExW(HKEY hkey, DWORD dwIndex, LPWSTR pszName, LPDWORD pcchName);
wchar_t * wmemset(wchar_t *s, wchar_t c, size_t n);
BOOL CryptEnumProvidersW(DWORD dwIndex, DWORD *pdwReserved, DWORD dwFlags, DWORD *pdwProvType, LPWSTR szProvName, DWORD *pcbProvName);
UINT GetDriveTypeW(LPCWSTR lpRootPathName);
HWND FindWindowA(LPCSTR lpClassName, LPCSTR lpWindowName);
LONG UnhandledExceptionFilter(unknown_t *ExceptionInfo);
BOOL CryptGetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
BOOL InitiateSystemShutdownExA(LPSTR lpMachineName, LPSTR lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown, DWORD dwReason);
HANDLE LoadImageA(HINSTANCE hInst, LPCSTR name, UINT type, int cx, int cy, UINT fuLoad);
LSTATUS RegQueryValueExW(HKEY hKey, LPCWSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
BOOL WSAGetOverlappedResult(SOCKET s, LPWSAOVERLAPPED lpOverlapped, LPDWORD lpcbTransfer, BOOL fWait, LPDWORD lpdwFlags);
BOOL ShellExecuteExW(unknown_t *pExecInfo);
BOOL IsGUIThread(BOOL bConvert);
BOOLEAN TranslateNameA(LPCSTR lpAccountName, EXTENDED_NAME_FORMAT AccountNameFormat, EXTENDED_NAME_FORMAT DesiredNameFormat, LPSTR lpTranslatedName, PULONG nSize);
ULONG LHashValOfNameSys(unknown_t syskind, LCID lcid, unknown_t *szName);
CONFIGRET CM_Query_Arbitrator_Free_Data(PVOID pData, ULONG DataLen, DEVINST dnDevInst, RESOURCEID ResourceID, ULONG ulFlags);
int WPUFDIsSet(SOCKET s, fd_set *fdset);
HWND FindWindowW(LPCWSTR lpClassName, LPCWSTR lpWindowName);
INT ldap_sasl_bind_sW(LDAP *ExternalHandle, PWSTR DistName, PWSTR AuthMechanism, BERVAL *cred, PLDAPControlW *ServerCtrls, PLDAPControlW *ClientCtrls, PBERVAL *ServerData);
HRESULT SafeArrayGetVartype(unknown_t *psa, VARTYPE *pvt);
BOOL ShellExecuteExA(unknown_t *pExecInfo);
PCHAR ldap_err2stringA(ULONG err);
HANDLE LoadImageW(HINSTANCE hInst, LPCWSTR name, UINT type, int cx, int cy, UINT fuLoad);
int wscanf(wchar_t *format);
BOOL CryptGenRandom(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer);
BOOLEAN TranslateNameW(LPCWSTR lpAccountName, EXTENDED_NAME_FORMAT AccountNameFormat, EXTENDED_NAME_FORMAT DesiredNameFormat, LPWSTR lpTranslatedName, PULONG nSize);
HCERTSTORE PFXImportCertStore(unknown_t *pPFX, LPCWSTR szPassword, DWORD dwFlags);
HRESULT UrlEscapeA(PCSTR pszUrl, PSTR pszEscaped, DWORD *pcchEscaped, DWORD dwFlags);
INT ldap_sasl_bind_sA(LDAP *ExternalHandle, const PSTR DistName, const PSTR AuthMechanism, BERVAL *cred, PLDAPControlA *ServerCtrls, PLDAPControlA *ClientCtrls, PBERVAL *ServerData);
BOOL SetFirmwareEnvironmentVariableA(LPCSTR lpName, LPCSTR lpGuid, PVOID pValue, DWORD nSize);
long strtoul(const char *str, char **endptr, int base);
BOOL EmptyClipboard();
int WSACancelAsyncRequest(HANDLE hAsyncTaskHandle);
PWCHAR ldap_err2stringW(ULONG err);
HRESULT UrlEscapeW(PCWSTR pszUrl, PWSTR pszEscaped, DWORD *pcchEscaped, DWORD dwFlags);
HRESULT VarI8FromDisp(unknown_t *pdispIn, LCID lcid, LONG64 *pi64Out);
char * strncat(char *s1, const char *s2, size_t n);
CHAR SHStripMneumonicA(LPSTR pszMenu);
BOOL GetPointerCursorId(UINT32 pointerId, UINT32 *cursorId);
DWORD GetFreeSpace(UINT ARG_0);
int ilogb(double x);
BOOL SetFirmwareEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpGuid, PVOID pValue, DWORD nSize);
LSTATUS SHRegSetValue(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, unknown_t srrfFlags, DWORD dwType, LPCVOID pvData, DWORD cbData);
BOOL PathUnquoteSpacesW(LPWSTR lpsz);
LONG TabbedTextOutA(HDC hdc, int x, int y, LPCSTR lpString, int chCount, int nTabPositions, INT *lpnTabStopPositions, int nTabOrigin);
WCHAR SHStripMneumonicW(LPWSTR pszMenu);
BOOL PathIsDirectoryEmptyA(LPCSTR pszPath);
BOOL IsThreadAFiber();
BOOL OpenThreadToken(HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle);
BOOL SetTextJustification(HDC hdc, int nBreakExtra, int nBreakCount);
ULONG ldap_search_stW(LDAP *ld, PWSTR base, ULONG scope, PWSTR filter, PZPWSTR attrs, ULONG attrsonly, struct l_timeval *timeout, PLDAPMessage *res);
INT WSALookupServiceEnd(HANDLE hLookup);
CONFIGRET CM_Open_Class_KeyW(LPGUID ClassGuid, LPCWSTR pszClassName, REGSAM samDesired, unknown_t Disposition, PHKEY phkClass, ULONG ulFlags);
LSTATUS RegSetKeyValueA(HKEY hKey, LPCSTR lpSubKey, LPCSTR lpValueName, DWORD dwType, LPCVOID lpData, DWORD cbData);
UINT GetBoundsRect(HDC hdc, LPRECT lprcBounds, UINT flags);
BOOL GetIconInfoExA(HICON hicon, PICONINFOEXA piconinfo);
BOOL PathIsDirectoryEmptyW(LPCWSTR pszPath);
int wvsprintfA(LPSTR ARG_0, LPCSTR ARG_1, va_list arglist);
CONFIGRET CM_Open_Class_KeyA(LPGUID ClassGuid, LPCSTR pszClassName, REGSAM samDesired, unknown_t Disposition, PHKEY phkClass, ULONG ulFlags);
long double hypotl(long double x, long double y);
BOOL CryptSignCertificate(BCRYPT_KEY_HANDLE hBCryptKey, DWORD dwKeySpec, DWORD dwCertEncodingType, BYTE *pbEncodedToBeSigned, DWORD cbEncodedToBeSigned, PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm, const void *pvHashAuxInfo, BYTE *pbSignature, DWORD *pcbSignature);
BOOL SetCaretBlinkTime(UINT uMSeconds);
LONG TabbedTextOutW(HDC hdc, int x, int y, LPCWSTR lpString, int chCount, int nTabPositions, INT *lpnTabStopPositions, int nTabOrigin);
SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerA(LPCSTR lpServiceName, unknown_t lpHandlerProc);
BOOL CryptExportPublicKeyInfoFromBCryptKeyHandle(BCRYPT_KEY_HANDLE hBCryptKey, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
void * objc_storeStrong(void *instance, int type);
float hypotf(float x, float y);
BOOL PathUnquoteSpacesA(LPSTR lpsz);
ULONG ldap_search_stA(LDAP *ld, const PSTR base, ULONG scope, const PSTR filter, PZPSTR attrs, ULONG attrsonly, struct l_timeval *timeout, PLDAPMessage *res);
LSTATUS RegSetKeyValueW(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpValueName, DWORD dwType, LPCVOID lpData, DWORD cbData);
int LBItemFromPt(HWND hLB, POINT pt, BOOL bAutoScroll);
BOOL GetIconInfoExW(HICON hicon, PICONINFOEXW piconinfo);
BOOL SymGetLineFromName64(HANDLE hProcess, PCSTR ModuleName, PCSTR FileName, DWORD dwLineNumber, PLONG plDisplacement, PIMAGEHLP_LINE64 Line);
BOOL WinHttpQueryAuthSchemes(HINTERNET hRequest, LPDWORD lpdwSupportedSchemes, LPDWORD lpdwFirstScheme, LPDWORD pdwAuthTarget);
BOOL SymGetLineNext(HANDLE hProcess, PIMAGEHLP_LINE Line);
SECURITY_STATUS NCryptIsAlgSupported(NCRYPT_PROV_HANDLE hProvider, LPCWSTR pszAlgId, DWORD dwFlags);
UINT GetWindowModuleFileNameA(HWND hwnd, LPSTR pszFileName, UINT cchFileNameMax);
BOOL EnumMetaFile(HDC hdc, HMETAFILE hmf, unknown_t lpMetaFunc, LPARAM lParam);
INT NSPStartup(LPGUID lpProviderId, LPNSP_ROUTINE lpnspRoutines);
BOOL ImageList_Write(HIMAGELIST himl, struct IStream *pstm);
int wvsprintfW(LPWSTR ARG_0, LPCWSTR ARG_1, va_list arglist);
BOOL ImageList_SetOverlayImage(HIMAGELIST himl, int iImage, int iOverlay);
BOOL GetPointerFrameTouchInfo(UINT32 pointerId, UINT32 *pointerCount, unknown_t *touchInfo);
BOOL SymGetSourceVarFromToken(HANDLE hProcess, PVOID Token, PCSTR Params, PCSTR VarName, PSTR Value, DWORD Size);
CONFIGRET CM_Get_Res_Des_Data_Size(PULONG pulSize, RES_DES rdResDes, ULONG ulFlags);
CONFIGRET CM_Get_Device_Interface_List_Size_ExW(PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags, HMACHINE hMachine);
ULONG ldap_delete_ext_sA(LDAP *ld, const PSTR dn, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerW(LPCWSTR lpServiceName, unknown_t lpHandlerProc);
HRESULT QueryHitRect(DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc, LONG lCloseHint, DWORD *pHitResult);
ULONG RtlNtStatusToDosError(NTSTATUS Status);
int StretchDIBits(HDC hdc, int XDest, int YDest, int nDestWidth, int nDestHeight, int XSrc, int YSrc, int nSrcWidth, int nSrcHeight, VOID *lpBits, BITMAPINFO *lpBitsInfo, unknown_t iUsage, unknown_t dwRop);
CONFIGRET CM_Delete_Device_Interface_KeyW(LPCWSTR pszDeviceInterface, ULONG ulFlags);
LSTATUS RegLoadMUIStringW(HKEY hKey, LPCWSTR pszValue, LPWSTR pszOutBuf, DWORD cbOutBuf, LPDWORD pcbData, DWORD Flags, LPCWSTR pszDirectory);
UINT GetWindowModuleFileNameW(HWND hwnd, LPWSTR pszFileName, UINT cchFileNameMax);
HRESULT VarAnd(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
HRESULT ApplicationRecoveryInProgress(PBOOL pbCancelled);
LPARAM GetMessageExtraInfo();
BOOL SymUnloadModule64(HANDLE hProcess, DWORD64 BaseOfDll);
CONFIGRET CM_Get_Device_Interface_List_Size_ExA(PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, ULONG ulFlags, HMACHINE hMachine);
CONFIGRET CM_Delete_Device_Interface_KeyA(LPCSTR pszDeviceInterface, ULONG ulFlags);
BOOL SetFirmwareEnvironmentVariableExW(LPCWSTR lpName, LPCWSTR lpGuid, PVOID pValue, DWORD nSize, DWORD dwAttributes);
BOOL GetFileAttributesTransactedW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation, HANDLE hTransaction);
LPWSTR PathGetArgsW(LPCWSTR pszPath);
double logb(double x);
int LCMapStringEx(LPCWSTR lpLocaleName, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest, LPNLSVERSIONINFO lpVersionInformation, LPVOID lpReserved, LPARAM sortHandle);
LSTATUS SHRegDeleteEmptyUSKeyW(HUSKEY hUSKey, LPCWSTR pwzSubKey, unknown_t delRegFlags);
DWORD GetOutlineTextMetricsW(HDC hdc, UINT cbData, unknown_t lpOTM);
ULONG ldap_delete_ext_sW(LDAP *ld, PWSTR dn, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls);
float logf(float x);
BOOL SetFirmwareEnvironmentVariableExA(LPCSTR lpName, LPCSTR lpGuid, PVOID pValue, DWORD nSize, DWORD dwAttributes);
BOOL EnumSystemLanguageGroupsA(LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam);
LSTATUS RegLoadMUIStringA(HKEY hKey, LPCSTR pszValue, LPSTR pszOutBuf, DWORD cbOutBuf, LPDWORD pcbData, DWORD Flags, LPCSTR pszDirectory);
INT_PTR DialogBoxParamW(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
LPSTR PathGetArgsA(LPCSTR pszPath);
DWORD SignalObjectAndWait(HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds, BOOL bAlertable);
long double logl(long double x);
DWORD GetOutlineTextMetricsA(HDC hdc, UINT cbData, unknown_t lpOTM);
uint32_t random();
LSTATUS SHRegDeleteEmptyUSKeyA(HUSKEY hUSKey, LPCSTR pszSubKey, unknown_t delRegFlags);
HRESULT GetDpiForMonitor(HMONITOR hmonitor, MONITOR_DPI_TYPE dpiType, UINT *dpiX, UINT *dpiY);
BOOL GetFileAttributesTransactedA(LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation, HANDLE hTransaction);
BOOL RegisterPointerInputTargetEx(HWND hwnd, unknown_t pointerType, BOOL fObserve);
BOOLEAN ldap_stop_tls_s(PLDAP ExternalHandle);
BOOL EnumSystemLanguageGroupsW(LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc, DWORD dwFlags, LONG_PTR lParam);
INT GetServiceA(DWORD dwNameSpace, LPGUID lpGuid, LPSTR lpServiceName, DWORD dwProperties, LPVOID lpBuffer, LPDWORD lpdwBufferSize, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo);
TRACEHANDLE GetTraceLoggerHandle(PVOID Buffer);
HPALETTE CreateHalftonePalette();
BOOL IsWindowVisible(HWND hWnd);
HANDLE WSAAsyncGetProtoByName(HWND hWnd, u_int wMsg, const char *name, char *buf, int buflen);
HANDLE BeginUpdateResourceW(LPCWSTR pFileName, BOOL bDeleteExistingResources);
long double tanl(long double x);
HRESULT VarI1FromDisp(unknown_t *pdispIn, LCID lcid, CHAR *pcOut);
VOID SetFileApisToOEM();
INT_PTR DialogBoxParamA(HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
int GetCalendarInfoEx(LPCWSTR lpLocaleName, CALID Calendar, LPCWSTR lpReserved, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue);
INT GetServiceW(DWORD dwNameSpace, LPGUID lpGuid, LPWSTR lpServiceName, DWORD dwProperties, LPVOID lpBuffer, LPDWORD lpdwBufferSize, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo);
float ldexpf(float value, int exp);
double tanh(double x);
INT WSARevertImpersonation();
BOOL DeleteTimerQueue(HANDLE TimerQueue);
float tanf(float x);
BOOL QueryDecompressorInformation(DECOMPRESSOR_HANDLE DecompressorHandle, COMPRESS_INFORMATION_CLASS CompressInformationClass, PVOID CompressInformation, SIZE_T CompressInformationSize);
BOOL CertControlStore(HCERTSTORE hCertStore, DWORD dwFlags, DWORD dwCtrlType, void *pvCtrlPara);
HANDLE BeginUpdateResourceA(LPCSTR pFileName, BOOL bDeleteExistingResources);
int wctob(wint_t c);
long double ldexpl(long double value, int exp);
DWORD GetLongPathNameTransactedW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer, HANDLE hTransaction);
HRESULT CoRegisterPSClsid(REFIID riid, unknown_t rclsid);
BOOL SetMenuInfo(HMENU ARG_0, LPCMENUINFO ARG_1);
BOOL UpdateLayeredWindowIndirect(HWND hWnd, unknown_t *pULWInfo);
BOOL SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL fByPositon, LPCMENUITEMINFOA lpmii);
HRESULT VarI2FromBool(unknown_t boolIn, SHORT *psOut);
BOOL SwitchDesktop(HDESK hDesktop);
BOOL GetWindowRect(HWND hWnd, LPRECT lpRect);
int isblank(int c);
BOOL CertCreateCertificateChainEngine(PCERT_CHAIN_ENGINE_CONFIG pConfig, HCERTCHAINENGINE *phChainEngine);
BOOL CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, LPCSTR pszOID, DWORD dwFlags, void **ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr);
DWORD GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh);
BOOL GetWindowPlacement(HWND hWnd, unknown_t *lpwndpl);
HRESULT CLSIDFromString(LPCOLESTR lpsz, LPCLSID pclsid);
HRESULT StgOpenAsyncDocfileOnIFillLockBytes(unknown_t *pflb, DWORD grfMode, DWORD asyncFlags, struct IStorage **ppstgOpen);
BOOLEAN Wow64EnableWow64FsRedirection(BOOLEAN Wow64FsEnableRedirection);
BOOL SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL fByPositon, LPCMENUITEMINFOW lpmii);
HRESULT CoDecodeProxy(DWORD dwClientPid, UINT64 ui64ProxyAddress, PServerInformation pServerInformation);
DWORD GetLongPathNameTransactedA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer, HANDLE hTransaction);
void ldap_perror(LDAP *ld, PCHAR msg);
char * strtok(char *s1, const char *s2);
HRESULT CoResumeClassObjects();
BOOL PrinterProperties(HWND hWnd, HPRINTER hPrinter);
HANDLE OpenProcess(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId);
HANDLE CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType);
long strtol(const char *str, char **endptr, int base);
int FlatSB_SetScrollPos(HWND ARG_0, int code, int pos, BOOL fRedraw);
ULONG EventAccessControl(LPGUID Guid, ULONG Operation, PSID Sid, ULONG Rights, BOOLEAN AllowOrDeny);
BOOL CryptCancelAsyncRetrieval(HCRYPTASYNC hAsyncRetrieval);
BOOL GetKernelObjectSecurity(HANDLE Handle, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
long long llround(double x);
CONFIGRET CM_Get_Device_ID_ExW(DEVINST dnDevInst, PWSTR Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine);
float strtof(const char *str, char **endptr);
VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
double strtod(const char *str, char **endptr);
HPEN CreatePen(unknown_t fnPenStyle, int nWidth, COLORREF crColor);
WORD GetWindowWord(HWND hWnd, int nIndex);
double log2(double x);
BOOL GlobalUnWire(HGLOBAL hMem);
BOOL CryptSetAsyncParam(HCRYPTASYNC hAsync, LPSTR pszParamOid, LPVOID pvParam, unknown_t pfnFree);
BOOL SystemTimeToFileTime(SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime);
LSTATUS RegQueryValueW(HKEY hKey, LPCWSTR lpSubKey, LPWSTR lpData, PLONG lpcbData);
CONFIGRET CM_Get_Device_ID_ExA(DEVINST dnDevInst, PSTR Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine);
int inet_aton(const char *cp, void *pin);
BOOL GetAutoRotationState(unknown_t pState);
int StrCSpnW(PCWSTR pszStr, PCWSTR pszSet);
BOOL IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar);
BOOL SetDynamicTimeZoneInformation(unknown_t *lpTimeZoneInformation);
int getsockname(SOCKET s, struct sockaddr *name, int *namelen);
CONFIGRET CM_Get_HW_Prof_FlagsW(DEVINSTID_W pDeviceID, ULONG ulHardwareProfile, PULONG pulValue, ULONG ulFlags);
DWORD SymCompareInlineTrace(HANDLE hProcess, DWORD64 Address1, DWORD InlineContext1, DWORD64 RetAddress1, DWORD64 Address2, DWORD64 RetAddress2);
HRESULT VarUI2FromUI4(ULONG ulIn, USHORT *puiOut);
DWORD FlsAlloc(unknown_t lpCallback);
LSTATUS RegConnectRegistryExA(LPCSTR lpMachineName, HKEY hKey, ULONG Flags, PHKEY phkResult);
HRESULT GetTypeInfoCount();
HRESULT VarUI2FromUI1(BYTE bIn, USHORT *puiOut);
CONFIGRET CM_Test_Range_Available(DWORDLONG ullStartValue, DWORDLONG ullEndValue, unknown_t rlh, ULONG ulFlags);
ULONG EnableTraceEx2(TRACEHANDLE TraceHandle, LPCGUID ProviderId, ULONG ControlCode, UCHAR Level, ULONGLONG MatchAnyKeyword, ULONGLONG MatchAllKeyword, ULONG Timeout, PENABLE_TRACE_PARAMETERS EnableParameters);
LSTATUS RegQueryValueA(HKEY hKey, LPCSTR lpSubKey, LPSTR lpData, PLONG lpcbData);
BOOL UnregisterDeviceNotification(HDEVNOTIFY Handle);
HRESULT VarUI2FromUI8(ULONG64 i64In, USHORT *puiOut);
BOOL IsClipboardFormatAvailable(UINT format);
BOOL CreateJobSet(ULONG NumJob, unknown_t UserJobSet, ULONG Flags);
SECURITY_STATUS NCryptFreeObject(NCRYPT_HANDLE hObject);
DWORD GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer);
COLORREF SetPixel(HDC hdc, int X, int Y, COLORREF crColor);
BOOL EnumerateLoadedModulesW64(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, PVOID UserContext);
int StrCSpnA(PCSTR pszStr, PCSTR pszSet);
CONFIGRET CM_Get_HW_Prof_FlagsA(DEVINSTID_A pDeviceID, ULONG ulHardwareProfile, PULONG pulValue, ULONG ulFlags);
WORD SetWindowWord(HWND hWnd, int nIndex, WORD wNewWord);
LSTATUS RegConnectRegistryExW(LPCWSTR lpMachineName, HKEY hKey, ULONG Flags, PHKEY phkResult);
HRESULT PathCchCanonicalizeEx(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn, ULONG dwFlags);
DWORD GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer);
ULONG ldap_get_paged_count(PLDAP ExternalHandle, PLDAPSearch SearchBlock, ULONG *TotalCount, PLDAPMessage Results);
int symlink(const char *path1, const char *path2);
int iswlower(wint_t wc);
int GetClipBox(HDC hdc, LPRECT lprc);
HRESULT VarBstrFromBool(unknown_t boolIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
BOOL OffsetRect(LPRECT lprc, int dx, int dy);
BOOL EqualSid(PSID pSid1, PSID pSid2);
int IdnToNameprepUnicode(DWORD dwFlags, LPCWSTR lpUnicodeCharStr, int cchUnicodeChar, LPWSTR lpNameprepCharStr, int cchNameprepChar);
PWSTR StrDupW(PCWSTR pszSrch);
LCID GetThreadLocale();
PCCRL_CONTEXT CertGetCRLFromStore(HCERTSTORE hCertStore, PCCERT_CONTEXT pIssuerContext, PCCRL_CONTEXT pPrevCrlContext, DWORD *pdwFlags);
HRESULT VarR8FromBool(unknown_t boolIn, DOUBLE *pdblOut);
HRESULT URLAssociationDialog(HWND hwndParent, unknown_t dwInFlags, LPCSTR pcszFile, LPCSTR pcszURL, LPSTR pszAppBuf, UINT ucAppBufLen);
int fwscanf(FILE *stream, wchar_t *format);
BOOL EnumEnhMetaFile(HDC hdc, HENHMETAFILE hemf, unknown_t lpEnhMetaFunc, LPVOID lpData, RECT *lpRect);
HRESULT GetClassFile(LPCOLESTR szFilename, unknown_t *pclsid);
PSTR StrDupA(PCSTR pszSrch);
BOOL DeletePrinterDataExW(HPRINTER hPrinter, LPWSTR pKeyName, LPWSTR pValueName);
BOOL GetTextExtentExPointI(HDC hdc, LPWORD pgiIn, int cgi, int nMaxExtent, LPINT lpnFit, LPINT alpDx, LPSIZE lpSize);
UINT GetDpiFromDpiAwarenessContext(DPI_AWARENESS_CONTEXT value);
HRESULT VarCyFromDisp(unknown_t *pdispIn, LCID lcid, unknown_t *pcyOut);
HRESULT VarUI2FromBool(unknown_t boolIn, USHORT *puiOut);
int isspace(int c);
BOOL CryptMsgEncodeAndSignCTL(DWORD dwMsgEncodingType, PCTL_INFO pCtlInfo, PCMSG_SIGNED_ENCODE_INFO pSignInfo, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded);
float nanf(const char *str);
BOOL CertRemoveEnhancedKeyUsageIdentifier(PCCERT_CONTEXT pCertContext, LPCSTR pszUsageIdentifier);
BOOL GetTextExtentExPointA(HDC hdc, LPCSTR lpszStr, int cchString, int nMaxExtent, LPINT lpnFit, LPINT alpDx, LPSIZE lpSize);
BOOL SymGetSourceFile(HANDLE hProcess, ULONG64 Base, PCSTR Params, PCSTR FileSpec, PSTR FilePath, DWORD Size);
LPWSTR CharLowerW(LPWSTR lpsz);
long double nanl(const char *str);
void BCryptFreeBuffer(PVOID pvBuffer);
BOOL SymGetSymFromName64(HANDLE hProcess, PCSTR Name, PIMAGEHLP_SYMBOL64 Symbol);
HMODULE LoadPackagedLibrary(LPCWSTR lpwLibFileName, DWORD Reserved);
ULONG ldap_free_controls(LDAPControlA **Controls);
HRESULT VarR4CmpR8(float fltLeft, double dblRight);
BOOL DeletePrinterDataExA(HPRINTER hPrinter, LPSTR pKeyName, LPSTR pValueName);
PSTR StrStrA(PCSTR pszFirst, PCSTR pszSrch);
BOOL SymGetLinePrev64(HANDLE hProcess, PIMAGEHLP_LINE64 Line);
BOOL GetThreadIOPendingFlag(HANDLE hThread, PBOOL lpIOIsPending);
HDC GetWindowDC(HWND hWnd);
BOOL AccessCheckByType(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus);
int SHCreateDirectoryExA(HWND hwnd, LPCSTR pszPath, SECURITY_ATTRIBUTES *psa);
CONFIGRET CM_Delete_DevNode_Key(DEVNODE dnDevNode, ULONG ulHardwareProfile, ULONG ulFlags);
HPRINTER ConnectToPrinterDlg(HWND hwnd, DWORD Flags);
BOOL PathCchIsRoot(PCWSTR pszPath);
BOOL GetTextExtentExPointW(HDC hdc, LPCWSTR lpszStr, int cchString, int nMaxExtent, LPINT lpnFit, LPINT alpDx, LPSIZE lpSize);
HRESULT VarDecFromDisp(unknown_t *pdispIn, LCID lcid, DECIMAL *pdecOut);
LPSTR CharLowerA(LPSTR lpsz);
HRESULT CoGetStdMarshalEx(LPUNKNOWN pUnkOuter, DWORD smexflags, LPUNKNOWN *ppUnkInner);
int fstat(int fildes, void *buf);
PWSTR StrStrW(PCWSTR pszFirst, PCWSTR pszSrch);
HRESULT CoSetCancelObject(IUnknown *pUnk);
int SHCreateDirectoryExW(HWND hwnd, LPCWSTR pszPath, SECURITY_ATTRIBUTES *psa);
VOID GlobalFix(HGLOBAL hMem);
BOOL EndPath();
BOOL DeleteFileW(LPCWSTR lpFileName);
BOOL TzSpecificLocalTimeToSystemTimeEx(unknown_t *lpTimeZoneInformation, SYSTEMTIME *lpLocalTime, LPSYSTEMTIME lpUniversalTime);
INT WSASetServiceW(LPWSAQUERYSETW lpqsRegInfo, WSAESETSERVICEOP essoperation, DWORD dwControlFlags);
HRESULT GetAppContainerFolderPath(PCWSTR pszAppContainerSid, PWSTR *ppszPath);
ULONG OaBuildVersion();
HRESULT GetViewStatus();
DWORD RaiseCustomSystemEventTrigger(unknown_t CustomSystemEventTriggerConfig);
NTSTATUS RtlUnicodeStringToOemString(POEM_STRING DestinationString, PCUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString);
long DescribePixelFormat(HDC hdc, int iPixelFormat, UINT nBytes, unknown_t ppfd);
BOOL DeleteFileA(LPCSTR lpFileName);
SC_HANDLE OpenSCManagerW(LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess);
HRESULT SHCreateThreadRef(LONG *pcRef, IUnknown **ppunk);
BOOL CopyFileExW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags);
BOOL IsBadHugeWritePtr(LPVOID lp, UINT_PTR ucb);
BOOL RequestDeviceWakeup(HANDLE hDevice);
DWORD GetLayout(HDC hdc);
ULONG EventSetInformation(REGHANDLE RegHandle, EVENT_INFO_CLASS InformationClass, PVOID EventInformation, ULONG InformationLength);
INT WSASetServiceA(LPWSAQUERYSETA lpqsRegInfo, WSAESETSERVICEOP essoperation, DWORD dwControlFlags);
HANDLE CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
HCURSOR LoadCursorA(HINSTANCE hInstance, LPCSTR lpCursorName);
HRESULT CreateObjrefMoniker(LPUNKNOWN punk, unknown_t *ppmk);
PCCRL_CONTEXT CertDuplicateCRLContext(PCCRL_CONTEXT pCrlContext);
SC_HANDLE OpenSCManagerA(LPCSTR lpMachineName, LPCSTR lpDatabaseName, DWORD dwDesiredAccess);
BOOL PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath);
BOOL CopyFileExA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags);
BOOL CryptRegisterOIDInfo(PCCRYPT_OID_INFO pInfo, DWORD dwFlags);
BOOL PathIsRootW(LPCWSTR pszPath);
SOCKET WSASocketA(int af, int type, int protocol, LPWSAPROTOCOL_INFOA lpProtocolInfo, GROUP g, DWORD dwFlags);
HANDLE CreateNamedPipeW(LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL UmsThreadYield(PVOID SchedulerParam);
BOOL SymGetSourceFileTokenW(HANDLE hProcess, ULONG64 Base, PCWSTR FileSpec, PVOID *Token, DWORD *Size);
DWORD EraseTape(HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate);
int WPUQueueApc(LPWSATHREADID lpThreadId, LPWSAUSERAPC lpfnUserApc, DWORD_PTR dwContext, LPINT lpErrno);
BOOL PathMakeSystemFolderW(LPCWSTR pszPath);
long lroundl(long double x);
BOOL CryptGetAsyncParam(HCRYPTASYNC hAsync, LPSTR pszParamOid, LPVOID *ppvParam, unknown_t *ppfnFree);
HRESULT VarUI1FromBool(unknown_t boolIn, BYTE *pbOut);
VOID CloseThreadpool(PTP_POOL ptpp);
BOOL SetUserObjectSecurity(HANDLE hObj, PSECURITY_INFORMATION pSIRequested, PSECURITY_DESCRIPTOR pSID);
long lroundf(float x);
BOOL PathMakeSystemFolderA(LPCSTR pszPath);
BOOL SetSystemFileCacheSize(SIZE_T MinimumFileCacheSize, SIZE_T MaximumFileCacheSize, DWORD Flags);
BOOL PathCanonicalizeA(LPSTR pszBuf, LPCSTR pszPath);
HFILE _lclose(HFILE hFile);
HCURSOR LoadCursorW(HINSTANCE hInstance, LPCWSTR lpCursorName);
SOCKET WSASocketW(int af, int type, int protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g, DWORD dwFlags);
BOOL CredMarshalCredentialW(CRED_MARSHAL_TYPE CredType, PVOID Credential, LPWSTR *MarshaledCredential);
BOOL PathIsRootA(LPCSTR pszPath);
BOOL CoIsOle1Class(unknown_t rclsid);
BOOL SymGetTypeFromNameW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Name, PSYMBOL_INFOW Symbol);
HBITMAP CreateDiscardableBitmap(HDC hdc, int nWidth, int nHeight);
HRESULT SHCreateShellItemArrayFromDataObject(unknown_t *pdo, REFIID riid, void **ppv);
int WPUGetProviderPath(LPGUID lpProviderId, WCHAR *lpszProviderDllPath, LPINT lpProviderDllPathLen, LPINT lpErrno);
BOOL PrintWindow(HWND hwnd, HDC hdcBlt, UINT nFlags);
DWORD OpenEncryptedFileRawW(LPCWSTR lpFileName, ULONG ulFlags, PVOID *pvContext);
int WSCEnumProtocols32(LPINT lpiProtocols, LPWSAPROTOCOL_INFOW lpProtocolBuffer, LPDWORD lpdwBufferLength, LPINT lpErrno);
long SHGlobalCounterIncrement(unknown_t id);
ULONG ldap_delete(LDAP *ld, PSTR dn);
UINT GetDlgItemInt(HWND hDlg, int nIDDlgItem, BOOL *lpTranslated, BOOL bSigned);
ULONG ldap_bind_sA(LDAP *ld, PSTR dn, PCHAR cred, ULONG method);
BOOL CreateCompressor(DWORD Algorithm, PCOMPRESS_ALLOCATION_ROUTINES AllocationRoutines, PCOMPRESSOR_HANDLE CompressorHandle);
CONFIGRET CM_Get_Device_ID_List_SizeW(PULONG pulLen, PCWSTR pszFilter, ULONG ulFlags);
void SafeArrayReleaseDescriptor(unknown_t *psa);
BOOL CredMarshalCredentialA(CRED_MARSHAL_TYPE CredType, PVOID Credential, LPSTR *MarshaledCredential);
BOOL SetProtectedPolicy(LPCGUID PolicyGuid, ULONG_PTR PolicyValue, PULONG_PTR OldPolicyValue);
BOOL CryptSIPRetrieveSubjectGuid(LPCWSTR FileName, HANDLE hFileIn, GUID *pgSubject);
HRESULT SHGetImageList(int iImageList, REFIID riid, void **ppvObj);
BOOL PathIsFileSpecW(LPCWSTR pszPath);
ULONG ldap_bind(LDAP *ld, const PSTR dn, PCHAR cred, ULONG method);
UINT GetTextAlign(HDC hdc);
int IdnToUnicode(DWORD dwFlags, LPCWSTR lpASCIICharStr, int cchASCIIChar, LPWSTR lpUnicodeCharStr, int cchUnicodeChar);
ULONG ldap_bind_sW(LDAP *ld, PWSTR dn, PWCHAR cred, ULONG method);
BOOL SymMatchFileName(PCSTR FileName, PCSTR Match, PSTR *FileNameStop, PSTR *MatchStop);
BOOL Polyline(HDC hdc, POINT *lppt, int cPoints);
PCCERT_CONTEXT CertCreateCertificateContext(DWORD dwCertEncodingType, BYTE *pbCertEncoded, DWORD cbCertEncoded);
DWORD OpenEncryptedFileRawA(LPCSTR lpFileName, ULONG ulFlags, PVOID *pvContext);
INT WSCUnInstallNameSpace(LPGUID lpProviderId);
CONFIGRET CM_Get_Device_ID_List_SizeA(PULONG pulLen, PCSTR pszFilter, ULONG ulFlags);
BOOL WinHttpCloseHandle(HINTERNET hInternet);
BOOL SetThreadErrorMode(DWORD dwNewMode, LPDWORD lpOldMode);
COLORREF SetBkColor(HDC hdc, COLORREF crColor);
double pow(double x, double y);
BOOL PathIsFileSpecA(LPCSTR pszPath);
HMENU LoadMenuW(HINSTANCE hInstance, LPCWSTR lpMenuName);
UINT GetCaretBlinkTime();
INT WSAUnadvertiseProvider(GUID *puuidProviderId);
BOOL SetFileSecurityW(LPCWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
HRESULT CoGetCancelObject(DWORD dwThreadId, REFIID iid, void **ppUnk);
BOOL CallEnclave(unknown_t lpRoutine, LPVOID lpParameter, BOOL fWaitForThread, LPVOID *lpReturnValue);
CONFIGRET CM_Get_Device_Interface_Alias_ExW(LPCWSTR pszDeviceInterface, LPGUID AliasInterfaceGuid, LPWSTR pszAliasDeviceInterface, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
HWND GetFocus();
HRESULT CoAllowUnmarshalerCLSID(unknown_t clsid);
HMENU LoadMenuA(HINSTANCE hInstance, LPCSTR lpMenuName);
CONFIGRET CM_Get_Class_Registry_PropertyA(LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
CONFIGRET CM_Move_DevNode_Ex(DEVINST dnFromDevInst, DEVINST dnToDevInst, ULONG ulFlags, HMACHINE hMachine);
BOOL InitializeSid(PSID Sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount);
BOOL SetSystemPowerState(BOOL fSuspend, BOOL fForce);
BOOL RemoveFontResourceW();
CONFIGRET CM_Get_Device_Interface_Alias_ExA(LPCSTR pszDeviceInterface, LPGUID AliasInterfaceGuid, LPSTR pszAliasDeviceInterface, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL IsHungAppWindow(HWND hwnd);
BOOL SetEnvironmentStringsW(LPWCH NewEnvironment);
BOOL SetFileSecurityA(LPCSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
BOOL CancelIoEx(HANDLE hFile, LPOVERLAPPED lpOverlapped);
BOOL DuplicateTokenEx(HANDLE hExistingToken, DWORD dwDesiredAccess, LPSECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, PHANDLE phNewToken);
BOOLEAN RtlInstallFunctionTableCallback(ULONG_PTR TableIdentifier, ULONG_PTR BaseAddress, ULONG Length, PGET_RUNTIME_FUNCTION_CALLBACK Callback, PVOID Context, PCWSTR OutOfProcessCallbackDll);
VOID CancelThreadpoolIo(PTP_IO pio);
VOID ldap_set_dbg_routine(unknown_t DebugPrintRoutine);
BOOL RemoveFontResourceA();
CONFIGRET CM_Get_Class_Registry_PropertyW(LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL InitializeContext(PVOID Buffer, DWORD ContextFlags, PCONTEXT *Context, PDWORD ContextLength);
DWORD GetEnhMetaFileDescriptionA(HENHMETAFILE hemf, UINT cchBuffer, LPSTR lpszDescription);
BOOL ClearEventLogW(HANDLE hEventLog, LPCWSTR lpBackupFileName);
BOOL SetDefaultCommConfigA(LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize);
HRESULT UnregisterApplicationRecoveryCallback();
BOOL TrackPopupMenu(HMENU hMenu, UINT uFlags, int x, int y, int nReserved, HWND hWnd, RECT *prcRect);
BOOL SetEnvironmentStringsA(LPCH NewEnvironment);
unknown_t * SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements);
BOOL CalculatePopupWindowPosition(POINT *anchorPoint, SIZE *windowSize, UINT flags, RECT *excludeRect, RECT *popupWindowPosition);
DWORD PowerGetActiveScheme(HKEY UserRootPowerKey, GUID **ActivePolicyGuid);
HRESULT VarI4FromR8(DOUBLE dblIn, LONG *plOut);
PCCERT_CONTEXT CertEnumCertificatesInStore(HCERTSTORE hCertStore, PCCERT_CONTEXT pPrevCertContext);
long atol(const char *str);
DWORD GetEnhMetaFileDescriptionW(HENHMETAFILE hemf, UINT cchBuffer, LPWSTR lpszDescription);
float log10f(float x);
DWORD WaitForSingleObjectEx(HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable);
int atoi(const char *str);
BOOL GetNumaProcessorNodeEx(PPROCESSOR_NUMBER Processor, PUSHORT NodeNumber);
HICON CreateIconFromResource(PBYTE presbits, DWORD dwResSize, BOOL fIcon, DWORD dwVer);
double atof(const char *str);
BOOL ClearEventLogA(HANDLE hEventLog, LPCSTR lpBackupFileName);
BOOL SetDefaultCommConfigW(LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize);
BOOL AddPrintProcessorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPathName, LPSTR pPrintProcessorName);
long double log10l(long double x);
CONFIGRET CM_Remove_SubTree(DEVINST dnAncestor, ULONG ulFlags);
int ilogbl(long double x);
float fdimf(float x, float y);
BOOL PolyPolygon(HDC hdc, POINT *lpPoints, INT *lpPolyCounts, int nCount);
HRESULT VarDateFromUdateEx(unknown_t *pudateIn, LCID lcid, ULONG dwFlags, unknown_t *pdateOut);
HRESULT VarI4FromR4(FLOAT fltIn, LONG *plOut);
BOOL SetThreadInformation(HANDLE hThread, THREAD_INFORMATION_CLASS ThreadInformationClass, LPVOID ThreadInformation, DWORD ThreadInformationSize);
int ilogbf(float x);
LSTATUS RegSetKeySecurity(HKEY hKey, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor);
int ioctl(int fd, unsigned long request);
double fabs(double x);
long double fdiml(long double x, long double y);
void SysReleaseString(BSTR bstrString);
DPI_AWARENESS_CONTEXT GetWindowDpiAwarenessContext(HWND hwnd);
BOOL AddPrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPathName, LPWSTR pPrintProcessorName);
BOOL SymEnumTypesByNameW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR mask, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
HRESULT DispInvoke(void *_this, unknown_t *ptinfo, unknown_t dispidMember, WORD wFlags, unknown_t *pparams, VARIANT *pvarResult, unknown_t *pexcepinfo, UINT *puArgErr);
BOOL CreateCaret(HWND hWnd, HBITMAP hBitmap, int nWidth, int nHeight);
INT WSAAddressToStringW(LPSOCKADDR lpsaAddress, DWORD dwAddressLength, LPWSAPROTOCOL_INFOW lpProtocolInfo, LPWSTR lpszAddressString, LPDWORD lpdwAddressStringLength);
VOID SetEventWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, HANDLE evt);
DWORD NotifyServiceStatusChangeA(SC_HANDLE hService, DWORD dwNotifyMask, unknown_t pNotifyBuffer);
INT WSAAddressToStringA(LPSOCKADDR lpsaAddress, DWORD dwAddressLength, LPWSAPROTOCOL_INFOA lpProtocolInfo, LPSTR lpszAddressString, LPDWORD lpdwAddressStringLength);
HWND GetLastActivePopup(HWND hWnd);
BOOL CryptGetObjectUrl(LPCSTR pszUrlOid, LPVOID pvPara, DWORD dwFlags, PCRYPT_URL_ARRAY pUrlArray, DWORD *pcbUrlArray, PCRYPT_URL_INFO pUrlInfo, DWORD *pcbUrlInfo, LPVOID pvReserved);
HRESULT IIDFromString(LPCOLESTR lpsz, LPIID lpiid);
int MessageBoxIndirectW(unknown_t *lpmbp);
BOOL EnumWindowStationsW(unknown_t lpEnumFunc, LPARAM lParam);
PWSTR StrRChrW(PCWSTR pszStart, PCWSTR pszEnd, WCHAR wMatch);
int MessageBoxIndirectA(unknown_t *lpmbp);
DWORD NotifyServiceStatusChangeW(SC_HANDLE hService, DWORD dwNotifyMask, unknown_t pNotifyBuffer);
HRESULT VarRound(LPVARIANT pvarIn, int cDecimals, LPVARIANT pvarResult);
BOOL GetPointerFrameInfoHistory(UINT32 pointerId, UINT32 *entriesCount, UINT32 *pointerCount, unknown_t *pointerInfo);
BOOL EnumWindowStationsA(unknown_t lpEnumFunc, LPARAM lParam);
BOOL SetCommState(HANDLE hFile, LPDCB lpDCB);
PSTR StrRChrA(PCSTR pszStart, PCSTR pszEnd, WORD wMatch);
CONFIGRET CM_Create_DevNodeW(unknown_t pdnDevInst, DEVINSTID_W pDeviceID, DEVINST dnParent, ULONG ulFlags);
BOOL GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength);
DWORD GetLengthSid(PSID pSid);
CONFIGRET CM_Get_Class_Property_ExW(LPCGUID ClassGUID, unknown_t *PropertyKey, unknown_t *PropertyType, PBYTE PropertyBuffer, PULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine);
HRESULT PathCchCombine(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn, PCWSTR pszMore);
long BroadcastSystemMessage(DWORD flags, LPDWORD lpInfo, UINT Msg, WPARAM wParam, LPARAM lParam);
CONFIGRET CM_Create_DevNodeA(unknown_t pdnDevInst, DEVINSTID_A pDeviceID, DEVINST dnParent, ULONG ulFlags);
LSTATUS RegUnLoadKeyW(HKEY hKey, LPCWSTR lpSubKey);
ULONG ldap_search(LDAP *ld, PSTR base, ULONG scope, PSTR filter, PZPSTR attrs, ULONG attrsonly);
BOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision);
BOOL GetNumaNodeProcessorMask(UCHAR Node, PULONGLONG ProcessorMask);
CONFIGRET CM_Set_DevNode_Registry_Property_ExA(DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL GetUserNameA(LPSTR lpBuffer, LPDWORD pcbBuffer);
LPVOID VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
void AVIFileExit();
CONFIGRET CM_Move_DevNode(DEVINST dnFromDevInst, DEVINST dnToDevInst, ULONG ulFlags);
CONFIGRET CM_Set_DevNode_Registry_Property_ExW(DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags, HMACHINE hMachine);
HRESULT CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, unknown_t *ppmk);
BOOL GetPointerPenInfo(UINT32 pointerId, unknown_t *penInfo);
HRESULT CoInstall(unknown_t *pbc, DWORD dwFlags, unknown_t *pClassSpec, unknown_t *pQuery, LPWSTR pszCodeBase);
LSTATUS RegUnLoadKeyA(HKEY hKey, LPCSTR lpSubKey);
BOOL PeekMessageW(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg);
HRESULT DcomChannelSetHResult(LPVOID pvReserved, ULONG *pulReserved, HRESULT appsHR);
BOOL EndDocPrinter();
BOOL GetUserNameW(LPWSTR lpBuffer, LPDWORD pcbBuffer);
HDC GetDC(HWND hWnd);
BOOL CryptSetKeyIdentifierProperty(unknown_t *pKeyIdentifier, DWORD dwPropId, DWORD dwFlags, LPCWSTR pwszComputerName, void *pvReserved, const void *pvData);
HRESULT SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, unknown_t *ppv, LPCITEMIDLIST *ppidlLast);
ULONG ldap_count_entries(LDAP *ld, LDAPMessage *res);
LPVOID ConvertThreadToFiberEx(LPVOID lpParameter, DWORD dwFlags);
void srandomdev();
BOOL PathFileExistsA(LPCSTR pszPath);
BOOL SetServiceStatus(SERVICE_STATUS_HANDLE hServiceStatus, LPSERVICE_STATUS lpServiceStatus);
INT GetAddressByNameW(DWORD dwNameSpace, LPGUID lpServiceType, LPWSTR lpServiceName, LPINT lpiProtocols, DWORD dwResolution, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo, LPVOID lpCsaddrBuffer, LPDWORD lpdwBufferLength, LPWSTR lpAliasBuffer, LPDWORD lpdwAliasBufferLength);
long long llroundf(float x);
HRESULT Draw(DWORD dwDrawAspect, LONG lindex, void *pvAspect, unknown_t *ptd, HDC hdcTargetDev, HDC hdcDraw, unknown_t lprcBounds, unknown_t lprcWBounds, unknown_t ContinueProc, ULONG_PTR dwContinue);
BOOL PeekMessageA(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg);
HRESULT UrlHashW(PCWSTR pszUrl, BYTE *pbHash, DWORD cbHash);
CONFIGRET CM_Get_Depth_Ex(PULONG pulDepth, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
BOOL EncryptFileA(LPCSTR lpFileName);
HRESULT OleLoadPicture(LPSTREAM lpstream, LONG lSize, BOOL fRunmode, REFIID riid, LPVOID *lplpvObj);
BOOL SetFileCompletionNotificationModes(HANDLE FileHandle, UCHAR Flags);
BOOL PathFileExistsW(LPCWSTR pszPath);
HRESULT OleCreatePropertyFrame(HWND hwndOwner, UINT x, UINT y, LPCOLESTR lpszCaption, ULONG cObjects, LPUNKNOWN *ppUnk, ULONG cPages, LPCLSID pPageClsID, LCID lcid, DWORD dwReserved, LPVOID pvReserved);
INT GetAddressByNameA(DWORD dwNameSpace, LPGUID lpServiceType, LPSTR lpServiceName, LPINT lpiProtocols, DWORD dwResolution, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo, LPVOID lpCsaddrBuffer, LPDWORD lpdwBufferLength, LPSTR lpAliasBuffer, LPDWORD lpdwAliasBufferLength);
BOOL WinHttpAddRequestHeaders(HINTERNET hRequest, LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwModifiers);
BOOL SymEnumLinesW(HANDLE hProcess, ULONG64 Base, PCWSTR Obj, PCWSTR File, PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, PVOID UserContext);
long long llroundl(long double x);
BOOL LogonUserExA(LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID *ppLogonSid, PVOID *ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits);
NTSTATUS BCryptDeriveKey(BCRYPT_SECRET_HANDLE hSharedSecret, LPCWSTR pwszKDF, unknown_t *pParameterList, PUCHAR pbDerivedKey, ULONG cbDerivedKey, ULONG *pcbResult, ULONG dwFlags);
BOOL CreatePrivateObjectSecurityWithMultipleInheritance(PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR *NewDescriptor, GUID **ObjectTypes, ULONG GuidCount, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping);
HRESULT CoGetInstanceFromFile(unknown_t *pServerInfo, unknown_t *pClsid, IUnknown *punkOuter, DWORD dwClsCtx, DWORD grfMode, unknown_t *pwszName, DWORD dwCount, unknown_t *pResults);
LCID GetUserDefaultLCID();
int umask(int m);
HRESULT GetIntegratedDisplaySize(double *sizeInInches);
HRESULT GetTypeInfo(UINT iTInfo, LCID lcid, LPVOID ppTInfo);
BOOL CryptEnumOIDInfo(DWORD dwGroupId, DWORD dwFlags, void *pvArg, PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo);
int GetWindowTextLengthW(HWND hWnd);
HRESULT SafeArrayLock(unknown_t *psa);
BOOL EncryptFileW(LPCWSTR lpFileName);
ULONG ldap_encode_sort_control(PLDAP ExternalHandle, PLDAPSortKeyA *SortKeys, PLDAPControlA Control, BOOLEAN Criticality);
VOID InitializeConditionVariable(PCONDITION_VARIABLE ConditionVariable);
HRESULT UrlHashA(PCSTR pszUrl, BYTE *pbHash, DWORD cbHash);
BOOL WSAConnectByList(SOCKET s, PSOCKET_ADDRESS_LIST SocketAddress, LPDWORD LocalAddressLength, LPSOCKADDR LocalAddress, LPDWORD RemoteAddressLength, LPSOCKADDR RemoteAddress, struct timeval *timeout, LPWSAOVERLAPPED Reserved);
BOOL EnableWindow(HWND hWnd, BOOL bEnable);
HRESULT SHGetInverseCMAP(BYTE *pbMap, ULONG cbMap);
HANDLE OpenCommPort(ULONG uPortNumber, DWORD dwDesiredAccess, DWORD dwFlagsAndAttributes);
BOOL SymSrvIsStoreW(HANDLE hProcess, PCWSTR path);
HMETAFILE CloseMetaFile();
BOOL LogonUserExW(LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken, PSID *ppLogonSid, PVOID *ppProfileBuffer, LPDWORD pdwProfileLength, PQUOTA_LIMITS pQuotaLimits);
int vfprintf(FILE *stream, const char *format, va_list ap);
void objc_retain(void *instance);
SIZE_T LocalSize(HLOCAL hMem);
BOOL PaintDesktop(HDC hdc);
int GetROP2(HDC hdc);
LSTATUS RegOpenUserClassesRoot(HANDLE hToken, DWORD dwOptions, REGSAM samDesired, PHKEY phkResult);
BOOL GetCommState(HANDLE hFile, LPDCB lpDCB);
BOOL SymEnumSymbols(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
DWORD QueryIoRateControlInformationJobObject(HANDLE hJob, PCWSTR VolumeName, unknown_t **InfoBlocks, ULONG *InfoBlockCount);
ULONG ldap_parse_reference(LDAP *Connection, LDAPMessage *ResultMessage, PCHAR **Referrals);
DWORD GetDynamicTimeZoneInformationEffectiveYears(const PDYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation, LPDWORD FirstYear, LPDWORD LastYear);
BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
HIMAGELIST ImageList_Merge(HIMAGELIST himl1, int i1, HIMAGELIST himl2, int i2, int dx, int dy);
BOOL GetGestureExtraArgs(unknown_t hGestureInfo, UINT cbExtraArgs, PBYTE pExtraArgs);
INT WSADeleteSocketPeerTargetName(SOCKET Socket, struct sockaddr *PeerAddr, ULONG PeerAddrLen, LPWSAOVERLAPPED Overlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine);
HPOWERNOTIFY RegisterSuspendResumeNotification(HANDLE hRecipient, DWORD Flags);
BOOL LookupAccountSidW(LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
UINT EnumClipboardFormats(UINT format);
int GetWindowTextLengthA(HWND hWnd);
HRESULT VarI4FromUI4(ULONG ulIn, LONG *plOut);
int GetRgnBox(HRGN HRGN, LPRECT lprc);
BOOL IsWindowUnicode(HWND hWnd);
PIMAGE_DEBUG_INFORMATION MapDebugInformation(HANDLE FileHandle, PCSTR FileName, PCSTR SymbolPath, ULONG ImageBase);
HRESULT VarI4FromUI2(USHORT uiIn, LONG *plOut);
HRESULT VarI4FromUI1(BYTE bIn, LONG *plOut);
BOOL AdjustWindowRectEx(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle);
BOOL CertGetCRLContextProperty(PCCRL_CONTEXT pCrlContext, DWORD dwPropId, void *pvData, DWORD *pcbData);
BOOL LookupAccountSidA(LPCSTR lpSystemName, PSID Sid, LPSTR Name, LPDWORD cchName, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
NTSTATUS RtlUnicodeToMultiByteSize(PULONG BytesInMultiByteString, PWCH UnicodeString, ULONG BytesInUnicodeString);
ULONG ldap_cleanup(HANDLE hInstance);
BOOL SymEnumerateModules64(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, PVOID UserContext);
VOID RtlGrowFunctionTable(PVOID DynamicTable, ULONG NewEntryCount);
HRESULT VarI4FromUI8(ULONG64 ui64In, LONG *plOut);
ULONG TraceSetInformation(TRACEHANDLE SessionHandle, TRACE_INFO_CLASS InformationClass, PVOID TraceInformation, ULONG InformationLength);
BOOL PrivilegeCheck(HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult);
int iswalnum(wint_t wc);
BOOL SymGetModuleInfo64(HANDLE hProcess, DWORD64 qwAddr, PIMAGEHLP_MODULE64 ModuleInfo);
int IdnToAscii(DWORD dwFlags, LPCWSTR lpUnicodeCharStr, int cchUnicodeChar, LPWSTR lpASCIICharStr, int cchASCIIChar);
BOOL EnumDateFormatsW(DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags);
BOOL SetViewportExtEx(HDC hdc, int nXExtent, int nYExtent, LPSIZE lpSize);
VOID InitOnceInitialize(PINIT_ONCE InitOnce);
float expm1f(float x);
HRESULT SafeArrayGetElement(unknown_t *psa, LONG *rgIndices, void *pv);
BOOL MiniDumpReadDumpStream(PVOID BaseOfDump, ULONG StreamNumber, PMINIDUMP_DIRECTORY *Dir, PVOID *StreamPointer, ULONG *StreamSize);
CONFIGRET CM_Get_Res_Des_Data(RES_DES rdResDes, PVOID Buffer, ULONG BufferLen, ULONG ulFlags);
CONFIGRET CM_Request_Device_EjectA(DEVINST dnDevInst, unknown_t pVetoType, LPSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags);
BOOL ColorMatchToTarget(HDC hDC, HDC hdcTarget, DWORD uiAction);
long double expm1l(long double x);
HPEN ExtCreatePen(unknown_t dwPenStyle, DWORD dwWidth, unknown_t *lplb, DWORD dwStyleCount, DWORD *lpStyle);
BOOL SymEnumerateModulesW64(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, PVOID UserContext);
USHORT Wow64SetThreadDefaultGuestMachine(USHORT Machine);
BOOL EnumDateFormatsA(DATEFMT_ENUMPROCA lpDateFmtEnumProc, LCID Locale, DWORD dwFlags);
ULONG ldap_compare_s(LDAP *ld, const PSTR dn, const PSTR attr, PSTR value);
BOOL GetModuleHandleExW(DWORD dwFlags, LPCWSTR lpModuleName, HMODULE *phModule);
BOOL EnableNonClientDpiScaling(HWND hwnd);
ULONG StopTraceW(TRACEHANDLE TraceHandle, LPCWSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
void SHChangeNotify(unknown_t wEventId, unknown_t uFlags, LPCVOID dwItem1, LPCVOID dwItem2);
int ShowCursor(BOOL bShow);
DWORD QueryThreadProfiling(HANDLE ThreadHandle, PBOOLEAN Enabled);
CONFIGRET CM_Request_Device_EjectW(DEVINST dnDevInst, unknown_t pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags);
BOOL EqualPrefixSid(PSID pSid1, PSID pSid2);
CONFIGRET CM_Run_Detection(ULONG ulFlags);
ULONG ldap_start_tls_sW(PLDAP ExternalHandle, PULONG ServerReturnValue, LDAPMessage **result, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls);
BOOL SymSetScopeFromAddr(HANDLE hProcess, ULONG64 Address);
VOID CloseThreadpoolCleanupGroup(PTP_CLEANUP_GROUP ptpcg);
BOOL GenerateConsoleCtrlEvent(DWORD dwCtrlEvent, DWORD dwProcessGroupId);
int WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg, long lEvent);
BOOL ReadDirectoryChangesExW(HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, READ_DIRECTORY_NOTIFY_INFORMATION_CLASS ReadDirectoryNotifyInformationClass);
ULONG StopTraceA(TRACEHANDLE TraceHandle, LPCSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
BOOL GetModuleHandleExA(DWORD dwFlags, LPCSTR lpModuleName, HMODULE *phModule);
HCRYPTMSG CryptMsgOpenToDecode(DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo, PCMSG_STREAM_INFO pStreamInfo);
ULONG ldap_compare_ext_sW(LDAP *ld, PWSTR dn, PWSTR Attr, PWSTR Value, struct berval *Data, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls);
PWSTR StrCatBuffW(PWSTR pszDest, PCWSTR pszSrc, int cchDestBuffSize);
double hypot(double x, double y);
BOOL AllocateUserPhysicalPagesNuma(HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray, DWORD nndPreferred);
WSAEVENT WPUCreateEvent(LPINT lpErrno);
ULONG ldap_start_tls_sA(PLDAP ExternalHandle, PULONG ServerReturnValue, LDAPMessage **result, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
double nan(const char *str);
BOOL CallNamedPipeA(LPCSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut);
HWINEVENTHOOK SetWinEventHook(DWORD eventMin, DWORD eventMax, HMODULE hmodWinEventProc, unknown_t pfnWinEventProc, DWORD idProcess, DWORD idThread, DWORD dwFlags);
PSTR StrCatBuffA(PSTR pszDest, PCSTR pszSrc, int cchDestBuffSize);
BOOL CertSetStoreProperty(HCERTSTORE hCertStore, DWORD dwPropId, DWORD dwFlags, const void *pvData);
BOOL FindNextStreamW(HANDLE hFindStream, LPVOID lpFindStreamData);
HRESULT VarCyAbs(unknown_t cyIn, unknown_t pcyResult);
ULONG ldap_compare_ext_sA(LDAP *ld, const PSTR dn, const PSTR Attr, const PSTR Value, struct berval *Data, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
int DrawEscape(HDC hdc, int nEscape, int cbInput, LPCSTR lpszInData);
LSTATUS SHRegEnumUSKeyA(HUSKEY hUSKey, DWORD dwIndex, LPSTR pszName, LPDWORD pcchName, unknown_t enumRegFlags);
BOOL CallNamedPipeW(LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut);
BOOL AddIntegrityLabelToBoundaryDescriptor(HANDLE *BoundaryDescriptor, PSID IntegrityLabel);
BOOLEAN ClosePrivateNamespace(HANDLE Handle, ULONG Flags);
BOOL EnumProcessModulesEx(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded, DWORD dwFilterFlag);
BOOL CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, LPCWSTR pwszDll, DWORD dwFlags, void **ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr);
BOOL SymGetModuleInfo(HANDLE hProcess, DWORD dwAddr, PIMAGEHLP_MODULE ModuleInfo);
COLORREF ColorHLSToRGB(WORD wHue, WORD wLuminance, WORD wSaturation);
LSTATUS SHRegEnumUSKeyW(HUSKEY hUSKey, DWORD dwIndex, LPWSTR pwzName, LPDWORD pcchName, unknown_t enumRegFlags);
int WSAIoctl(SOCKET s, DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer, LPDWORD lpcbBytesReturned, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
double cosh(double x);
long SetGraphicsMode(HDC hdc, unknown_t iMode);
UINT GetDlgItemTextW(HWND hDlg, int nIDDlgItem, LPWSTR lpString, int cchMax);
ULONG ldap_modrdn_sW(LDAP *ExternalHandle, PWSTR DistinguishedName, PWSTR NewDistinguishedName);
long double cosl(long double x);
ULONG ldap_modify_ext_s(LDAP *ld, const PSTR dn, unknown_t **mods, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
BOOL CryptMsgClose(HCRYPTMSG hCryptMsg);
BOOL PolyTextOutW(HDC hdc, unknown_t *pptxt, int cStrings);
float cosf(float x);
BOOL DebugSetProcessKillOnExit(BOOL KillOnExit);
BOOL EnumResourceTypesExA(HMODULE hModule, ENUMRESTYPEPROCA lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
HANDLE CreateSemaphoreExA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
ULONG ldap_modrdn_sA(LDAP *ExternalHandle, const PSTR DistinguishedName, const PSTR NewDistinguishedName);
ULONG ldap_simple_bindW(LDAP *ld, PWSTR dn, PWSTR passwd);
BOOL IsProcessDPIAware();
ssize_t write(int fd, const char *ptr, size_t nbytes);
BOOL SHGetNewLinkInfoW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName, BOOL *pfMustCopy, UINT uFlags);
BOOL SymFromAddr(HANDLE hProcess, DWORD64 Address, PDWORD64 Displacement, PSYMBOL_INFO Symbol);
UINT GetDlgItemTextA(HWND hDlg, int nIDDlgItem, LPSTR lpString, int cchMax);
BOOL CloseServiceHandle(SC_HANDLE hSCObject);
HRESULT DeriveRestrictedAppContainerSidFromAppContainerSidAndRestrictedName(PSID psidAppContainerSid, PCWSTR pszRestrictedAppContainerName, PSID *ppsidRestrictedAppContainerSid);
HANDLE CreateSemaphoreExW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
HINSTANCE CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree);
intmax_t wcstoimax(wchar_t *nptr, wchar_t **endptr, int base);
BOOL PolyTextOutA(HDC hdc, unknown_t *pptxt, int cStrings);
HRESULT PowerUnregisterFromEffectivePowerModeNotifications(VOID *RegistrationHandle);
BOOL EnumResourceTypesExW(HMODULE hModule, ENUMRESTYPEPROCW lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
ULONG ldap_simple_bindA(LDAP *ld, PSTR dn, PSTR passwd);
BOOL GetMenuItemRect(HWND hWnd, HMENU hMenu, UINT uItem, LPRECT lprcItem);
BOOL SHGetNewLinkInfoA(LPCSTR pszLinkTo, LPCSTR pszDir, LPSTR pszName, BOOL *pfMustCopy, UINT uFlags);
BOOL SHGetDiskFreeSpaceExW(LPCWSTR pszDirectoryName, ULARGE_INTEGER *pulFreeBytesAvailableToCaller, ULARGE_INTEGER *pulTotalNumberOfBytes, ULARGE_INTEGER *pulTotalNumberOfFreeBytes);
LSTATUS RegCreateKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult);
NTSTATUS BCryptHashData(BCRYPT_HASH_HANDLE hHash, PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
UINT _lread(HFILE hFile, LPVOID lpBuffer, UINT uBytes);
BOOL IsBadReadPtr(VOID *lp, UINT_PTR ucb);
void RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString);
UINT SetHandleCount(UINT uNumber);
PCWSTR SymSrvStoreFileW(HANDLE hProcess, PCWSTR SrvPath, PCWSTR File, DWORD Flags);
BOOL SHGetDiskFreeSpaceExA(LPCSTR pszDirectoryName, ULARGE_INTEGER *pulFreeBytesAvailableToCaller, ULARGE_INTEGER *pulTotalNumberOfBytes, ULARGE_INTEGER *pulTotalNumberOfFreeBytes);
LSTATUS RegCreateKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult);
SHORT VkKeyScanW(WCHAR ch);
size_t strftime(char *s, size_t maxsize, const char *format, struct tm *timeptr);
BOOL GetWorldTransform(HDC hdc, unknown_t lpXform);
bool signbit(double x);
INT WSCEnumNameSpaceProviders32(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOW lpnspBuffer);
CONFIGRET CM_Delete_Class_Key_Ex(LPGUID ClassGuid, ULONG ulFlags, HMACHINE hMachine);
HRESULT VarR4FromR8(DOUBLE dblIn, FLOAT *pfltOut);
SHORT VkKeyScanA(CHAR ch);
void rewind(FILE *stream);
BOOL PrivilegedServiceAuditAlarmW(LPCWSTR SubsystemName, LPCWSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted);
HANDLE GetStdHandle(DWORD nStdHandle);
BOOL SetDoubleClickTime(UINT ARG_0);
CONFIGRET CM_Get_Global_State(PULONG pulState, ULONG ulFlags);
bool isless(double x, double y);
BOOL GetPointerFramePenInfo(UINT32 pointerId, UINT32 *pointerCount, unknown_t *penInfo);
BOOL ModifyWorldTransform(HDC hdc, unknown_t *lpXform, DWORD iMode);
HRESULT VarDateFromUdate(unknown_t *pudateIn, ULONG dwFlags, unknown_t *pdateOut);
HRESULT VarBstrFromDate(unknown_t dateIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
HRESULT VarUI4FromR8(DOUBLE dblIn, ULONG *pulOut);
BOOL GetPointerPenInfoHistory(UINT32 pointerId, UINT32 *entriesCount, unknown_t *penInfo);
HFILE _lcreat(LPCSTR lpPathName, int iAttribute);
BOOL Beep(DWORD dwFreq, DWORD dwDuration);
BOOL ChangeWindowMessageFilter(UINT message, DWORD dwFlag);
BOOL CharToOemA(LPCSTR pSrc, LPSTR pDst);
HRESULT VarUI4FromR4(FLOAT fltIn, ULONG *pulOut);
HDESK OpenDesktopA(LPCSTR lpszDesktop, DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
BOOL InitializeTouchInjection(UINT32 maxCount, DWORD dwMode);
BOOL PrivilegedServiceAuditAlarmA(LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted);
BOOL SetThreadStackGuarantee(PULONG StackSizeInBytes);
ULONG ldap_modify_ext(LDAP *ld, const PSTR dn, unknown_t **mods, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
VOID SetThreadpoolThreadMaximum(PTP_POOL ptpp, DWORD cthrdMost);
DWORD_PTR SHGetFileInfoA(LPCSTR pszPath, DWORD dwFileAttributes, unknown_t *psfi, UINT cbFileInfo, UINT uFlags);
PVOID VirtualAllocFromApp(PVOID BaseAddress, SIZE_T Size, ULONG AllocationType, ULONG Protection);
UINT MapVirtualKeyA(UINT uCode, UINT uMapType);
HRESULT MonikerCommonPrefixWith(unknown_t pmkThis, unknown_t pmkOther, unknown_t *ppmkCommon);
BOOL DragDetect(HWND hwnd, POINT pt);
HDESK OpenDesktopW(LPCWSTR lpszDesktop, DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
bool isinf(double x);
HANDLE AddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts);
BOOL SetCurrentDirectoryA(LPCSTR lpPathName);
BOOL CharToOemW(LPCWSTR pSrc, LPSTR pDst);
UINT MapVirtualKeyW(UINT uCode, UINT uMapType);
LANGID GetThreadUILanguage();
ATOM GlobalAddAtomW(LPCWSTR lpString);
BOOL DeleteUmsThreadContext(PUMS_CONTEXT UmsThread);
COLORREF GetTextColor();
UINT GetConsoleCP();
BOOL EnumDeviceDrivers(LPVOID *lpImageBase, DWORD cb, LPDWORD lpcbNeeded);
int FindStringOrdinal(DWORD dwFindStringOrdinalFlags, LPCWSTR lpStringSource, int cchSource, LPCWSTR lpStringValue, int cchValue, BOOL bIgnoreCase);
BOOL CryptCreateAsyncHandle(DWORD dwFlags, unknown_t phAsync);
BOOL SetCurrentDirectoryW(LPCWSTR lpPathName);
long SetROP2(HDC hdc, unknown_t fnDrawMode);
int SetWindowRgn(HWND hWnd, HRGN hRgn, BOOL bRedraw);
ATOM GlobalAddAtomA(LPCSTR lpString);
DWORD_PTR SHGetFileInfoW(LPCWSTR pszPath, DWORD dwFileAttributes, unknown_t *psfi, UINT cbFileInfo, UINT uFlags);
int fts_close_INODE64(void *ftsp);
HRESULT SHAutoComplete(HWND hwndEdit, DWORD dwFlags);
BOOL SetSystemTime(SYSTEMTIME *lpSystemTime);
int GetGraphicsMode(HDC hdc);
HRESULT GetScaleFactorForMonitor(HMONITOR hMon, DEVICE_SCALE_FACTOR *pScale);
PWSTR StrCatW(PWSTR psz1, PCWSTR psz2);
BOOL CryptSignMessage(PCRYPT_SIGN_MESSAGE_PARA pSignPara, BOOL fDetachedSignature, DWORD cToBeSigned, BYTE **rgpbToBeSigned, DWORD *rgcbToBeSigned, BYTE *pbSignedBlob, DWORD *pcbSignedBlob);
BOOL LoadEnclaveImageW(LPVOID lpEnclaveAddress, LPCWSTR lpImageName);
HBITMAP LoadBitmapA(HINSTANCE hInstance, LPCSTR lpBitmapName);
DWORD K32GetDeviceDriverFileNameW(LPVOID ImageBase, LPWSTR lpFilename, DWORD nSize);
BOOL CertEnumSystemStore(DWORD dwFlags, void *pvSystemStoreLocationPara, void *pvArg, PFN_CERT_ENUM_SYSTEM_STORE pfnEnum);
SECURITY_STATUS NCryptQueryProtectionDescriptorName(LPCWSTR pwszName, LPWSTR pwszDescriptorString, SIZE_T *pcDescriptorString, DWORD dwFlags);
HANDLE CreateConsoleScreenBuffer(DWORD dwDesiredAccess, DWORD dwShareMode, SECURITY_ATTRIBUTES *lpSecurityAttributes, DWORD dwFlags, LPVOID lpScreenBufferData);
void * memset(void *s, int c, size_t n);
long BroadcastSystemMessageExA(DWORD flags, LPDWORD lpInfo, UINT Msg, WPARAM wParam, LPARAM lParam, PBSMINFO pbsmInfo);
BOOL SymEnumerateSymbolsW(HANDLE hProcess, ULONG BaseOfDll, PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
BOOL LoadEnclaveImageA(LPVOID lpEnclaveAddress, LPCSTR lpImageName);
BOOL GetFirmwareType(PFIRMWARE_TYPE FirmwareType);
void CoFreeUnusedLibraries();
HBITMAP LoadBitmapW(HINSTANCE hInstance, LPCWSTR lpBitmapName);
int feclearexcept(int excepts);
BOOL IsProcessCritical(HANDLE hProcess, PBOOL Critical);
LPCH GetEnvironmentStrings();
DWORD K32GetDeviceDriverFileNameA(LPVOID ImageBase, LPSTR lpFilename, DWORD nSize);
BOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID *pGroup, LPBOOL lpbGroupDefaulted);
BOOL InsertMenuA(HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem);
BOOL GetCharABCWidthsW(HDC hdc, UINT uFirstChar, UINT uLastChar, unknown_t lpabc);
BOOL PtInRegion(HRGN HRGN, int X, int Y);
HANDLE OpenEventLogW(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName);
BOOL SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod);
long BroadcastSystemMessageExW(DWORD flags, LPDWORD lpInfo, UINT Msg, WPARAM wParam, LPARAM lParam, PBSMINFO pbsmInfo);
int raise(int sig);
BOOL GetPrinterW(HPRINTER hPrinter, int Level, LPBYTE pPrinter, int cbBuf, int *pcbNeeded);
VOID ReleaseSRWLockExclusive(PSRWLOCK SRWLock);
LRESULT DefWindowProcA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
int GetDateFormatA(LCID Locale, DWORD dwFlags, SYSTEMTIME *lpDate, LPCSTR lpFormat, LPSTR lpDateStr, int cchDate);
HANDLE OpenEventLogA(LPCSTR lpUNCServerName, LPCSTR lpSourceName);
BOOL GetCharABCWidthsI(HDC hdc, UINT giFirst, UINT cgi, LPWORD pgi, unknown_t lpabc);
BOOL SetThreadGroupAffinity(HANDLE hThread, unknown_t *GroupAffinity, unknown_t PreviousGroupAffinity);
HDWP BeginDeferWindowPos(int nNumWindows);
float sqrtf(float x);
BOOL AdjustWindowRectExForDpi(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle, UINT dpi);
BOOL SetPropW(HWND hWnd, LPCWSTR lpString, HANDLE hData);
UINT PathGetCharTypeW(WCHAR ch);
BOOL InsertMenuW(HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem);
BOOL GetCharABCWidthsA(HDC hdc, UINT uFirstChar, UINT uLastChar, unknown_t lpabc);
long double sqrtl(long double x);
HRSRC FindResourceA(HMODULE hModule, LPCSTR lpName, LPCSTR lpType);
int GetDateFormatW(LCID Locale, DWORD dwFlags, SYSTEMTIME *lpDate, LPCWSTR lpFormat, LPWSTR lpDateStr, int cchDate);
BOOL GetPrinterA(HPRINTER hPrinter, int Level, LPBYTE pPrinter, int cbBuf, int *pcbNeeded);
VOID CertCloseServerOcspResponse(HCERT_SERVER_OCSP_RESPONSE hServerOcspResponse, DWORD dwFlags);
DWORD GetPrivateProfileSectionNamesA(LPSTR lpszReturnBuffer, DWORD nSize, LPCSTR lpFileName);
BOOL CryptGetDefaultProviderW(DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags, LPWSTR pszProvName, DWORD *pcbProvName);
BOOL PlayEnhMetaFile(HDC hdc, HENHMETAFILE hemf, RECT *lpRect);
wctrans_t wctrans(const char *property);
BOOL IsWow64Process2(HANDLE hProcess, USHORT *pProcessMachine, USHORT *pNativeMachine);
LRESULT DefWindowProcW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
UINT EnumSystemFirmwareTables(DWORD FirmwareTableProviderSignature, PVOID pFirmwareTableEnumBuffer, DWORD BufferSize);
HRESULT SHGetPropertyStoreForWindow(HWND hwnd, REFIID riid, void **ppv);
BOOL SetPropA(HWND hWnd, LPCSTR lpString, HANDLE hData);
CONFIGRET CM_Get_Device_Interface_List_SizeW(PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags);
BOOL RegisterGPNotification(HANDLE hEvent, BOOL bMachine);
HRESULT VarR4FromDec(DECIMAL *pdecIn, FLOAT *pfltOut);
int feraiseexcept(int excepts);
BOOL CancelWaitableTimer(HANDLE hTimer);
HRSRC FindResourceW(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType);
ULONG ldap_free_controlsW(LDAPControlW **Controls);
BOOL SymSetScopeFromIndex(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index);
UINT PathGetCharTypeA(UCHAR ch);
ULONG ldap_simple_bind_s(LDAP *ld, const PSTR dn, const PSTR passwd);
CONFIGRET CM_Get_Device_Interface_List_SizeA(PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, ULONG ulFlags);
PCHAR ldap_dn2ufn(const PSTR dn);
BOOL MessageBeep(UINT uType);
DWORD DoEnvironmentSubstW(LPWSTR pszSrc, UINT cchSrc);
BOOL GetWindowsAccountDomainSid(PSID pSid, PSID pDomainSid, DWORD *cbDomainSid);
BOOL CryptGetDefaultProviderA(DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags, LPSTR pszProvName, DWORD *pcbProvName);
NTSTATUS CallNtPowerInformation(POWER_INFORMATION_LEVEL InformationLevel, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength);
DWORD GetPrivateProfileSectionNamesW(LPWSTR lpszReturnBuffer, DWORD nSize, LPCWSTR lpFileName);
CONFIGRET CM_Get_Device_ID_Size_Ex(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
SECURITY_STATUS NCryptKeyDerivation(NCRYPT_KEY_HANDLE hKey, unknown_t *pParameterList, PUCHAR pbDerivedKey, DWORD cbDerivedKey, DWORD *pcbResult, ULONG dwFlags);
HANDLE OpenJobObjectA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
HRESULT SafeArrayPtrOfIndex(unknown_t *psa, LONG *rgIndices, void **ppvData);
BOOL UpdateICMRegKeyW(DWORD dwReserved, LPWSTR lpszCMID, LPWSTR lpszFileName, unknown_t nCommand);
DWORD DoEnvironmentSubstA(LPSTR pszSrc, UINT cchSrc);
long double scalblnl(long double x, long ex);
ULONG ldap_free_controlsA(LDAPControlA **Controls);
HANDLE OpenFileById(HANDLE hVolumeHint, LPFILE_ID_DESCRIPTOR lpFileId, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwFlagsAndAttributes);
HRESULT GetProcessReference(IUnknown **punk);
BOOL CryptGetTimeValidObject(LPCSTR pszTimeValidOid, LPVOID pvPara, PCCERT_CONTEXT pIssuer, LPFILETIME pftValidFor, DWORD dwFlags, DWORD dwTimeout, LPVOID *ppvObject, PCRYPT_CREDENTIALS pCredentials, PCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO pExtraInfo);
int EndPage();
HRESULT VarDecSub(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
SECURITY_STATUS NCryptStreamOpenToUnprotectEx(unknown_t *pStreamInfo, DWORD dwFlags, HWND hWnd, NCRYPT_STREAM_HANDLE *phStream);
DWORD CredUICmdLinePromptForCredentialsA(PCSTR pszTargetName, PCtxtHandle pContext, DWORD dwAuthError, PSTR UserName, ULONG ulUserBufferSize, PSTR pszPassword, ULONG ulPasswordBufferSize, PBOOL pfSave, DWORD dwFlags);
HMENU CreateMenu();
BOOL PtInRect(RECT *lprc, POINT pt);
float scalblnf(float x, long ex);
ULONG ldap_get_option(LDAP *ld, int option, void *outvalue);
double sin(double x);
BOOL SetComputerNameEx2W(COMPUTER_NAME_FORMAT NameType, DWORD Flags, LPCWSTR lpBuffer);
HANDLE OpenJobObjectW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
BOOL UpdateICMRegKeyA(DWORD dwReserved, LPSTR lpszCMID, LPSTR lpszFileName, unknown_t nCommand);
PTP_IO CreateThreadpoolIo(HANDLE fl, PTP_WIN32_IO_CALLBACK pfnio, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
BOOL K32EnumPageFilesW(PENUM_PAGE_FILE_CALLBACKW pCallBackRoutine, LPVOID pContext);
size_t wcsspn(wchar_t *s1, wchar_t *s2);
COLORREF GetBkColor();
BOOL CryptEncryptMessage(PCRYPT_ENCRYPT_MESSAGE_PARA pEncryptPara, DWORD cRecipientCert, PCCERT_CONTEXT *rgpRecipientCert, BYTE *pbToBeEncrypted, DWORD cbToBeEncrypted, BYTE *pbEncryptedBlob, DWORD *pcbEncryptedBlob);
HWND WindowFromDC(HDC hDC);
DWORD CredUICmdLinePromptForCredentialsW(PCWSTR pszTargetName, PCtxtHandle pContext, DWORD dwAuthError, PWSTR UserName, ULONG ulUserBufferSize, PWSTR pszPassword, ULONG ulPasswordBufferSize, PBOOL pfSave, DWORD dwFlags);
BOOL SetFormW(HPRINTER hPrinter, LPWSTR pFormName, int Level, unknown_t pForm);
long long llrint(double x);
BOOL DeletePrinterDriverA(LPSTR pName, LPSTR pEnvironment, LPSTR pDriverName);
void * xmalloc(size_t size);
BOOL K32EnumPageFilesA(PENUM_PAGE_FILE_CALLBACKA pCallBackRoutine, LPVOID pContext);
HRESULT VarCyFromUI1(BYTE bIn, unknown_t *pcyOut);
BOOL SetProcessPriorityBoost(HANDLE hProcess, BOOL bDisablePriorityBoost);
HRESULT VarCyFromUI2(USHORT uiIn, unknown_t *pcyOut);
NTSTATUS BCryptImportKey(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_KEY_HANDLE hImportKey, LPCWSTR pszBlobType, BCRYPT_KEY_HANDLE *phKey, PUCHAR pbKeyObject, ULONG cbKeyObject, PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
HRESULT VarCyFromUI4(ULONG ulIn, unknown_t *pcyOut);
INT_PTR DialogBoxIndirectParamW(HINSTANCE hInstance, LPCDLGTEMPLATEW hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
BOOL EndPaint(HWND hWnd, unknown_t *lpPaint);
BOOL IsValidLocale(LCID Locale, DWORD dwFlags);
BOOL PurgeComm(HANDLE hFile, DWORD dwFlags);
DWORD GetFontLanguageInfo();
BOOL SetFormA(HPRINTER hPrinter, LPSTR pFormName, int Level, unknown_t pForm);
HRESULT VarCyFromUI8(ULONG64 ui64In, unknown_t *pcyOut);
BOOL UnmapViewOfFile(LPCVOID lpBaseAddress);
HRESULT IUnknown_GetSite(IUnknown *punk, REFIID riid, void **ppv);
ULONG ldap_rename_extA(LDAP *ld, const PSTR dn, const PSTR NewRDN, const PSTR NewParent, INT DeleteOldRdn, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
long GetDialogBaseUnits();
BOOL FlushInstructionCache(HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize);
BOOL DeletePrinterDriverW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pDriverName);
BOOL QueryActCtxW(DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInstance, ULONG ulInfoClass, PVOID pvBuffer, SIZE_T cbBuffer, SIZE_T *pcbWrittenOrRequired);
__uint64 htonll(__uint64 Value);
BOOL SymFromInlineContextW(HANDLE hProcess, DWORD64 Address, ULONG InlineContext, PDWORD64 Displacement, PSYMBOL_INFOW Symbol);
HRESULT VarCyFromI4(LONG lIn, unknown_t *pcyOut);
INT_PTR DialogBoxIndirectParamA(HINSTANCE hInstance, LPCDLGTEMPLATEA hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
CONFIGRET CM_Delete_DevNode_Key_Ex(DEVNODE dnDevNode, ULONG ulHardwareProfile, ULONG ulFlags, HMACHINE hMachine);
ULONG ldap_rename_extW(LDAP *ld, PWSTR dn, PWSTR NewRDN, PWSTR NewParent, INT DeleteOldRdn, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, ULONG *MessageNumber);
HRESULT VarCyFromI1(CHAR cIn, unknown_t *pcyOut);
int EnumObjects(HDC hdc, int nObjectType, unknown_t lpObjectFunc, LPARAM lParam);
BOOL WinHttpQueryAuthParams(HINTERNET hRequest, DWORD AuthScheme, LPVOID *pAuthParams);
LPVOID VirtualAllocEx(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
HRESULT PathCchAppendEx(PWSTR pszPath, size_t cchPath, PCWSTR pszMore, ULONG dwFlags);
HRESULT VarCyFromI2(SHORT sIn, unknown_t *pcyOut);
long GetFontUnicodeRanges(HDC hdc, unknown_t lpgs);
BOOL QueryWorkingSet(HANDLE hProcess, PVOID pv, DWORD cb);
HRESULT VarCyFromI8(LONG64 i64In, unknown_t *pcyOut);
DWORD SetIoRateControlInformationJobObject(HANDLE hJob, unknown_t *IoRateControlInfo);
DPI_HOSTING_BEHAVIOR GetWindowDpiHostingBehavior(HWND hwnd);
HANDLE OpenMutexA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
BOOL IsBadHugeReadPtr(VOID *lp, UINT_PTR ucb);
BOOL AdvancedDocumentPropertiesW(HWND hWnd, HPRINTER hPrinter, LPWSTR pDeviceName, unknown_t pDevModeOutput, unknown_t pDevModeInput);
DWORD GenerateGPNotification(BOOL bMachine, LPCWSTR lpwszMgmtProduct, DWORD dwMgmtProductOptions);
int ToAscii(UINT uVirtKey, UINT uScanCode, BYTE *lpKeyState, LPWORD lpChar, UINT uFlags);
BOOL SymEnumSymbolsExW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext, DWORD Options);
BOOL FindActCtxSectionStringA(DWORD dwFlags, GUID *lpExtensionGuid, ULONG ulSectionId, LPCSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData);
BOOL ConvertFiberToThread();
int lstrcmpA(LPCSTR lpString1, LPCSTR lpString2);
BOOL SwapMouseButton(BOOL fSwap);
BOOL AdvancedDocumentPropertiesA(HWND hWnd, HPRINTER hPrinter, LPSTR pDeviceName, unknown_t pDevModeOutput, unknown_t pDevModeInput);
HANDLE OpenMutexW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
BOOL Chord(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect, int nXRadial1, int nYRadial1, int nXRadial2, int nYRadial2);
CONFIGRET CM_Uninstall_DevNode(DEVNODE dnDevInst, ULONG ulFlags);
BOOL FlatSB_ShowScrollBar(HWND ARG_0, int code, BOOL ARG_2);
BOOL FindActCtxSectionStringW(DWORD dwFlags, GUID *lpExtensionGuid, ULONG ulSectionId, LPCWSTR lpStringToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData);
int LoadStringW(HINSTANCE hInstance, UINT uID, LPWSTR lpBuffer, int cchBufferMax);
BOOL GetQueuedCompletionStatusEx(HANDLE CompletionPort, unknown_t lpCompletionPortEntries, ULONG ulCount, PULONG ulNumEntriesRemoved, DWORD dwMilliseconds, BOOL fAlertable);
BOOL UnregisterHotKey(HWND hWnd, int id);
BOOL DlgDirSelectComboBoxExW(HWND hwndDlg, LPWSTR lpString, int cchOut, int idComboBox);
long GetRegionData(HRGN HRGN, DWORD dwCount, unknown_t lpRgnData);
BOOL CertCompareCertificate(DWORD dwCertEncodingType, PCERT_INFO pCertId1, PCERT_INFO pCertId2);
int lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2);
HRESULT IStream_Reset(struct IStream *pstm);
void SetSymLoadError(DWORD error);
HRESULT Load(LPCOLESTR pszFileName, DWORD dwMode);
HRESULT VarCyAdd(unknown_t cyLeft, unknown_t cyRight, unknown_t pcyResult);
ULONG EventRegister(LPCGUID ProviderId, PENABLECALLBACK EnableCallback, PVOID CallbackContext, PREGHANDLE RegHandle);
BOOL CreateDecompressor(DWORD Algorithm, PCOMPRESS_ALLOCATION_ROUTINES AllocationRoutines, PDECOMPRESSOR_HANDLE DecompressorHandle);
BOOL BuildCommDCBW(LPCWSTR lpDef, LPDCB lpDCB);
DWORD SetPaletteEntries(HPALETTE hpal, UINT iStart, UINT cEntries, unknown_t *lppe);
VOID mouse_event(DWORD dwFlags, DWORD dx, DWORD dy, DWORD dwData, ULONG_PTR dwExtraInfo);
VOID GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer);
BOOL DlgDirSelectComboBoxExA(HWND hwndDlg, LPSTR lpString, int cchOut, int idComboBox);
int LoadStringA(HINSTANCE hInstance, UINT uID, LPSTR lpBuffer, int cchBufferMax);
LONG RegEnableReflectionKey(HKEY hBase);
DWORD WriteTapemark(HANDLE hDevice, DWORD dwTapemarkType, DWORD dwTapemarkCount, BOOL bImmediate);
HRESULT SHGetFolderPathW(HWND hwndOwner, unknown_t nFolder, HANDLE hToken, unknown_t dwFlags, LPWSTR pszPath);
UINT GetSystemWindowsDirectoryA(LPSTR lpBuffer, UINT uSize);
BOOL BuildCommDCBA(LPCSTR lpDef, LPDCB lpDCB);
BOOL GetWindowInfo(HWND hwnd, PWINDOWINFO pwi);
BOOL ReadConsoleOutputAttribute(HANDLE hConsoleOutput, LPWORD lpAttribute, DWORD nLength, COORD dwReadCoord, LPDWORD lpNumberOfAttrsRead);
HRESULT SafeArrayGetIID(unknown_t *psa, GUID *pguid);
HRESULT SHCreateItemFromRelativeName(unknown_t *psiParent, PCWSTR pszName, unknown_t *pbc, REFIID riid, void **ppv);
HRESULT SafeArrayAddRef(unknown_t *psa, PVOID *ppDataToRelease);
VOID CloseThreadpoolIo(PTP_IO pio);
HRESULT VarUI4FromI4(LONG lIn, ULONG *pulOut);
double erf(double x);
HRESULT SHGetFolderPathA(HWND hwndOwner, unknown_t nFolder, HANDLE hToken, unknown_t dwFlags, LPSTR pszPath);
HRESULT VarUI4FromI2(SHORT uiIn, ULONG *pulOut);
BOOL CryptSignMessageWithKey(PCRYPT_KEY_SIGN_MESSAGE_PARA pSignPara, BYTE *pbToBeSigned, DWORD cbToBeSigned, BYTE *pbSignedBlob, DWORD *pcbSignedBlob);
BOOL EnumUILanguagesA(UILANGUAGE_ENUMPROCA lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam);
HRESULT VarUI4FromI1(CHAR cIn, ULONG *pulOut);
int GetTimeFormatA(LCID Locale, DWORD dwFlags, SYSTEMTIME *lpTime, LPCSTR lpFormat, LPSTR lpTimeStr, int cchTime);
INT WSCInstallNameSpaceEx(LPWSTR lpszIdentifier, LPWSTR lpszPathName, DWORD dwNameSpace, DWORD dwVersion, LPGUID lpProviderId, LPBLOB lpProviderSpecific);
BOOL AddMandatoryAce(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD MandatoryPolicy, PSID pLabelSid);
long long atoll(const char *str);
COLORREF ImageList_GetBkColor(HIMAGELIST himl);
UINT GetSystemWindowsDirectoryW(LPWSTR lpBuffer, UINT uSize);
BOOL UnlockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh);
BOOL EnumServicesStatusExW(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR pszGroupName);
HRESULT VarUI1FromR8(DOUBLE dblIn, BYTE *pbOut);
HRESULT VarUI4FromI8(LONG64 i64In, ULONG *plOut);
ULONG ldap_controls_freeW(LDAPControlW **Control);
BOOL CertAddCTLContextToStore(HCERTSTORE hCertStore, PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition, PCCTL_CONTEXT *ppStoreContext);
long SHGlobalCounterGetValue(unknown_t id);
int GetTimeFormatW(LCID Locale, DWORD dwFlags, SYSTEMTIME *lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, int cchTime);
CONFIGRET CM_Get_Class_Name_ExA(LPGUID ClassGuid, PSTR Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL CredRenameA(LPCSTR OldTargetName, LPCSTR NewTargetName, DWORD Type, DWORD Flags);
BOOL EnumUILanguagesW(UILANGUAGE_ENUMPROCW lpUILanguageEnumProc, DWORD dwFlags, LONG_PTR lParam);
BOOL EnumServicesStatusExA(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCSTR pszGroupName);
int tolower(int c);
wchar_t * wcsstr(wchar_t *s1, wchar_t *s2);
HRESULT VarUI1FromR4(FLOAT fltIn, BYTE *pbOut);
HRESULT CoRevokeInitializeSpy(ULARGE_INTEGER uliCookie);
ULONG ldap_controls_freeA(LDAPControlA **Controls);
ULONG ldap_add_ext_sW(LDAP *ld, PWSTR dn, unknown_t **attrs, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls);
LRESULT PackTouchHitTestingProximityEvaluation(unknown_t *pHitTestingInput, unknown_t *pProximityEval);
BOOL SetFileInformationByHandle(HANDLE hFile, FILE_INFO_BY_HANDLE_CLASS FileInformationClass, LPVOID lpFileInformation, DWORD dwBufferSize);
BOOL CredRenameW(LPCWSTR OldTargetName, LPCWSTR NewTargetName, DWORD Type, DWORD Flags);
BOOL TlsFree(DWORD dwTlsIndex);
BOOL PolyBezier(HDC hdc, POINT *lppt, DWORD cPoints);
BOOL CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey);
double log(double x);
CONFIGRET CM_Get_Class_Name_ExW(LPGUID ClassGuid, PWSTR Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
ULONG ldap_add_ext_sA(LDAP *ld, const PSTR dn, unknown_t **attrs, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
DWORD64 GetEnabledXStateFeatures();
BOOL EnumDisplayDevicesA(LPCSTR lpDevice, DWORD iDevNum, PDISPLAY_DEVICEA lpDisplayDevice, DWORD dwFlags);
long double fminl(long double x, long double y);
BOOL WSAConnectByNameA(SOCKET s, LPCSTR nodename, LPCSTR servicename, LPDWORD LocalAddressLength, LPSOCKADDR LocalAddress, LPDWORD RemoteAddressLength, LPSOCKADDR RemoteAddress, struct timeval *timeout, LPWSAOVERLAPPED Reserved);
LRESULT SHSendMessageBroadcastW(UINT uMsg, WPARAM wParam, LPARAM lParam);
CONFIGRET CM_Free_Range_List(unknown_t rlh, ULONG ulFlags);
size_t strcspn(const char *s1, const char *s2);
HBITMAP CreateDIBSection(HDC hdc, BITMAPINFO *pbmi, UINT iUsage, VOID **ppvBits, HANDLE hSection, DWORD dwOffset);
VOID CertFreeServerOcspResponseContext(PCCERT_SERVER_OCSP_RESPONSE_CONTEXT pServerOcspResponseContext);
BOOL GetPointerInputTransform(UINT32 pointerId, UINT32 historyCount, unknown_t *inputTransform);
BOOL EnumDisplayDevicesW(LPCWSTR lpDevice, DWORD iDevNum, PDISPLAY_DEVICEW lpDisplayDevice, DWORD dwFlags);
float fminf(float x, float y);
NTSTATUS BCryptFinishHash(BCRYPT_HASH_HANDLE hHash, PUCHAR pbOutput, ULONG cbOutput, ULONG dwFlags);
double expm1(double x);
HRESULT VarUI4FromDec(DECIMAL *pdecIn, ULONG *pulOut);
PCHAR ldap_dn2ufnA(const PSTR dn);
int ReleaseDC(HWND hWnd, HDC hDC);
BOOL WSAConnectByNameW(SOCKET s, LPWSTR nodename, LPWSTR servicename, LPDWORD LocalAddressLength, LPSOCKADDR LocalAddress, LPDWORD RemoteAddressLength, LPSOCKADDR RemoteAddress, struct timeval *timeout, LPWSAOVERLAPPED Reserved);
ULONG ldap_check_filterW(LDAP *ld, PWSTR SearchFilter);
PWCHAR ldap_dn2ufnW(PWSTR dn);
long double lgammal(long double x);
UINT GetSystemPaletteUse(HDC hdc);
LRESULT SHSendMessageBroadcastA(UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL TransmitCommChar(HANDLE hFile, char cChar);
ATOM GlobalFindAtomW(LPCWSTR lpString);
BOOL CryptDeriveKey(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData, DWORD dwFlags, HCRYPTKEY *phKey);
LONG GetDisplayConfigBufferSizes(UINT32 flags, UINT32 *numPathArrayElements, UINT32 *numModeInfoArrayElements);
float lgammaf(float x);
VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
BOOL GetRasterizerCaps(unknown_t lprs, UINT cb);
BOOL UnregisterClassW(LPCWSTR lpClassName, HINSTANCE hInstance);
int NormalizeString(NORM_FORM NormForm, LPCWSTR lpSrcString, int cwSrcLength, LPWSTR lpDstString, int cwDstLength);
BOOL ShowWindowAsync(HWND hWnd, int nCmdShow);
UINT ArrangeIconicWindows(HWND hWnd);
ULONG ldap_check_filterA(LDAP *ld, PSTR SearchFilter);
BOOL BitBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, unknown_t dwRop);
BOOL EnableMouseInPointerForThread();
BOOL EnumSystemCodePagesW(CODEPAGE_ENUMPROCW lpCodePageEnumProc, DWORD dwFlags);
BOOL ChangeWindowMessageFilterEx(HWND hwnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
INT WSAStringToAddressW(LPWSTR AddressString, INT AddressFamily, LPWSAPROTOCOL_INFOW lpProtocolInfo, LPSOCKADDR lpAddress, LPINT lpAddressLength);
BOOL UnregisterClassA(LPCSTR lpClassName, HINSTANCE hInstance);
BOOL WPUSetEvent(WSAEVENT hEvent, LPINT lpErrno);
BOOL OperationStart(unknown_t *OperationStartParams);
BOOL SymUnDName(PIMAGEHLP_SYMBOL sym, PSTR UnDecName, DWORD UnDecNameLength);
ATOM GlobalFindAtomA(LPCSTR lpString);
DWORD GetDllDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer);
HRESULT CoRevertToSelf();
VOID SetLastError(DWORD dwErrCode);
INT WSAStringToAddressA(LPSTR AddressString, INT AddressFamily, LPWSAPROTOCOL_INFOA lpProtocolInfo, LPSOCKADDR lpAddress, LPINT lpAddressLength);
BOOL VerifyVersionInfoA(LPOSVERSIONINFOEXA lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask);
ULONG ldap_count_valuesA(PCHAR *vals);
LDAP * cldap_open(PSTR HostName, ULONG PortNumber);
BOOL CryptGetKeyParam(HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
BOOL InvalidateRgn(HWND hWnd, HRGN hRgn, BOOL bErase);
BOOL NeedCurrentDirectoryForExePathA(LPCSTR ExeName);
DWORD PowerSettingRegisterNotification(LPCGUID SettingGuid, DWORD Flags, HANDLE Recipient, PHPOWERNOTIFY RegistrationHandle);
BOOL EnumSystemCodePagesA(CODEPAGE_ENUMPROCA lpCodePageEnumProc, DWORD dwFlags);
int fflush(FILE *stream);
INT WSCEnableNSProvider32(LPGUID lpProviderId, BOOL fEnable);
BOOL VerifyVersionInfoW(LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask);
ULONG ldap_count_valuesW(PWCHAR *vals);
BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
HRESULT OleLoadPictureEx(LPSTREAM lpstream, LONG lSize, BOOL fRunmode, REFIID riid, DWORD xSizeDesired, DWORD ySizeDesired, DWORD dwFlags, LPVOID *lplpvObj);
BOOL SymRefreshModuleList(HANDLE hProcess);
int sendto(SOCKET s, const char *buf, int len, int flags, struct sockaddr *to, int tolen);
DWORD GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart);
PSTR StrChrA(PCSTR pszStart, WORD wMatch);
BOOL CallbackMayRunLong(PTP_CALLBACK_INSTANCE pci);
DWORD GetDllDirectoryA(DWORD nBufferLength, LPSTR lpBuffer);
ULONG ldap_parse_sort_control(PLDAP ExternalHandle, PLDAPControlA *Control, ULONG *Result, PCHAR *Attribute);
BOOL SymSrvIsStore(HANDLE hProcess, PCSTR path);
HRESULT VarDecCmpR8(LPDECIMAL pdecLeft, double dblRight);
BOOL CryptEncrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen);
BOOL NeedCurrentDirectoryForExePathW(LPCWSTR ExeName);
BOOL WinHttpCrackUrl(LPCWSTR pwszUrl, DWORD dwUrlLength, DWORD dwFlags, LPURL_COMPONENTS lpUrlComponents);
BOOL IsLFNDriveW(LPCWSTR pszPath);
BOOL SetSystemCursor(HCURSOR hcur, DWORD id);
DWORD GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart);
CONFIGRET CM_Set_DevNode_Problem_Ex(DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags, HMACHINE hMachine);
BOOL SymGetTypeInfoEx(HANDLE hProcess, DWORD64 ModBase, PIMAGEHLP_GET_TYPE_INFO_PARAMS Params);
wint_t btowc(int c);
BOOL GetPointerInfoHistory(UINT32 pointerId, UINT32 *entriesCount, unknown_t *pointerInfo);
PWSTR StrChrW(PCWSTR pszStart, WCHAR wMatch);
BOOL EnumDateFormatsExA(DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags);
int FlatSB_SetScrollInfo(HWND ARG_0, int code, LPSCROLLINFO psi, BOOL fRedraw);
HRESULT ConvertAuxiliaryCounterToPerformanceCounter(ULONGLONG ullAuxiliaryCounterValue, PULONGLONG lpPerformanceCounterValue, PULONGLONG lpConversionError);
BOOL GetCommConfig(HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize);
int InternalGetWindowText(HWND hWnd, LPWSTR pString, int cchMaxCount);
int EnumFontsW(HDC hdc, LPCWSTR lpFaceName, unknown_t lpFontFunc, LPARAM lParam);
int ExcludeClipRect(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
HRESULT PathCchSkipRoot(PCWSTR pszPath, PCWSTR *ppszRootEnd);
UINT WhichPlatform();
SECURITY_STATUS NCryptOpenStorageProvider(NCRYPT_PROV_HANDLE *phProvider, LPCWSTR pszProviderName, DWORD dwFlags);
BOOL WriteFileEx(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
BOOL EnumDateFormatsExW(DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, LCID Locale, DWORD dwFlags);
BOOL ShowOwnedPopups(HWND hWnd, BOOL fShow);
HRESULT GetThreadDescription(HANDLE hThread, PWSTR *ppszThreadDescription);
int sprintf_chk(char *s, const char *format, va_list args);
BOOL IsLFNDriveA(LPCSTR pszPath);
HANDLE CreateActCtxW(PCACTCTXW pActCtx);
BOOL GetBinaryTypeA(LPCSTR lpApplicationName, LPDWORD lpBinaryType);
HWND SetParent(HWND hWndChild, HWND hWndNewParent);
int EnumFontsA(HDC hdc, LPCSTR lpFaceName, unknown_t lpFontFunc, LPARAM lParam);
HANDLE CreateActCtxA(PCACTCTXA pActCtx);
HRESULT GetRunningObjectTable(DWORD reserved, unknown_t *pprot);
HANDLE SymFindExecutableImage(HANDLE hProcess, PCSTR FileName, PSTR ImageFilePath, PFIND_EXE_FILE_CALLBACK Callback, PVOID CallerData);
int GetTextCharsetInfo(HDC hdc, unknown_t lpSig, DWORD dwFlags);
BOOL GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType);
LPSTR PathAddBackslashA(LPSTR pszPath);
HRESULT VarUI8FromDate(unknown_t dateIn, ULONG64 *pi64Out);
BOOL AnyPopup();
void RtlFreeUnicodeString(PUNICODE_STRING UnicodeString);
BOOL SetUserGeoName(PWSTR geoName);
LPWSTR PathAddBackslashW(LPWSTR pszPath);
HCERTSTORE CertDuplicateStore(HCERTSTORE hCertStore);
LSTATUS RegCopyTreeW(HKEY hKeySrc, LPCWSTR lpSubKey, HKEY hKeyDest);
HRESULT QueryAuxiliaryCounterFrequency(PULONGLONG lpAuxiliaryCounterFrequency);
ULONG ldap_count_references(LDAP *ld, LDAPMessage *res);
HRESULT CoSetProxyBlanket(IUnknown *pProxy, DWORD dwAuthnSvc, DWORD dwAuthzSvc, unknown_t *pServerPrincName, DWORD dwAuthnLevel, DWORD dwImpLevel, RPC_AUTH_IDENTITY_HANDLE pAuthInfo, DWORD dwCapabilities);
BOOL GetUpdatedClipboardFormats(PUINT lpuiFormats, UINT cFormats, PUINT pcFormatsOut);
BOOL SymDeleteSymbol(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Name, DWORD64 Address, DWORD Flags);
long AddFontResourceExA(LPCSTR lpszFilename, unknown_t fl, unknown_t *pdv);
BOOL DeregisterShellHookWindow(HWND hwnd);
LSTATUS RegCopyTreeA(HKEY hKeySrc, LPCSTR lpSubKey, HKEY hKeyDest);
HRESULT SHSetLocalizedName(PCWSTR pszPath, PCWSTR pszResModule, int idsRes);
int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
BOOL CryptHashCertificate2(LPCWSTR pwszCNGHashAlgid, DWORD dwFlags, void *pvReserved, BYTE *pbEncoded, DWORD cbEncoded, BYTE *pbComputedHash, DWORD *pcbComputedHash);
BOOL EnumPortsW(LPWSTR pName, int Level, LPBYTE pPorts, int cbBuf, int *pcbNeeded, int *pcReturned);
BOOL ExtFloodFill(HDC hdc, int nXStart, int nYStart, COLORREF crColor, unknown_t fuFillType);
VOID GlobalUnfix(HGLOBAL hMem);
UINT GetOEMCP();
HLOCAL LocalAlloc(UINT uFlags, SIZE_T uBytes);
HRESULT VarUI1FromI2(SHORT sIn, BYTE *pbOut);
int WSADuplicateSocketW(SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo);
HRESULT VarUI1FromI1(CHAR cIn, BYTE *pbOut);
VOID CertFreeCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext);
ULONG ldap_count_values_len(struct berval **vals);
HRESULT VarUI1FromI4(LONG lIn, BYTE *pbOut);
LPSTR PathCombineA(LPSTR pszDest, LPCSTR pszDir, LPCSTR pszFile);
long AddFontResourceExW(LPCWSTR lpszFilename, unknown_t fl, unknown_t *pdv);
BOOL HiliteMenuItem(HWND hWnd, HMENU hMenu, UINT uIDHiliteItem, UINT uHilite);
DWORD EnableThreadProfiling(HANDLE ThreadHandle, DWORD Flags, DWORD64 HardwareCounters, HANDLE *PerformanceDataHandle);
HRESULT VarUI1FromI8(LONG64 i64In, BYTE *pbOut);
HRESULT PathCchRemoveExtension(PWSTR pszPath, size_t cchPath);
double floor(double x);
HRESULT VarInt(LPVARIANT pvarIn, LPVARIANT pvarResult);
HRESULT PropVariantCopy(unknown_t *pvarDest, unknown_t *pvarSrc);
BOOL SymGetLineFromNameW64(HANDLE hProcess, PCWSTR ModuleName, PCWSTR FileName, DWORD dwLineNumber, PLONG plDisplacement, PIMAGEHLP_LINEW64 Line);
BOOL EnumPortsA(LPSTR pName, int Level, LPBYTE pPorts, int cbBuf, int *pcbNeeded, int *pcReturned);
int WSADuplicateSocketA(SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOA lpProtocolInfo);
LSTATUS SHDeleteKeyW(HKEY hkey, LPCWSTR pszSubKey);
ULONG ldap_value_free_len(struct berval **vals);
long GetStretchBltMode();
int WSCInstallQOSTemplate(LPGUID Guid, LPWSABUF QosName, LPQOS Qos);
HRESULT SafeArrayCopy(unknown_t *psa, unknown_t **ppsaOut);
BOOL StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE TranslateAddress);
unknown_t * getservbyport(int port, const char *proto);
BOOL SetPrivateObjectSecurity(SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor, PGENERIC_MAPPING GenericMapping, HANDLE Token);
LPWSTR PathCombineW(LPWSTR pszDest, LPCWSTR pszDir, LPCWSTR pszFile);
LSTATUS SHDeleteKeyA(HKEY hkey, LPCSTR pszSubKey);
int iswalpha(wint_t wc);
int GetKeyNameTextW(LONG lParam, LPWSTR lpString, int cchSize);
HCRYPTMSG CryptMsgDuplicate(HCRYPTMSG hCryptMsg);
BOOL SetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength);
CONFIGRET CM_Get_DevNode_Property_Keys(DEVINST dnDevInst, unknown_t *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags);
NTSTATUS BCryptQueryContextFunctionConfiguration(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, ULONG *pcbBuffer, PCRYPT_CONTEXT_FUNCTION_CONFIG *ppBuffer);
BOOL GetMiterLimit(HDC hdc, PFLOAT peLimit);
HRESULT VarUI4FromCy(unknown_t cyIn, ULONG *pulOut);
BOOL EnumTimeFormatsW(TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags);
BOOL AddAuditAccessObjectAce(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID *ObjectTypeGuid, GUID *InheritedObjectTypeGuid, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure);
INT WSAGetServiceClassInfoA(LPGUID lpProviderId, LPGUID lpServiceClassId, LPDWORD lpdwBufSize, LPWSASERVICECLASSINFOA lpServiceClassInfo);
BOOL SetDefaultDllDirectories(DWORD DirectoryFlags);
DWORD GetCurrentProcessId();
BOOL CopySid(DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid);
DWORD WinHttpCreateProxyResolver(HINTERNET hSession, HINTERNET *phResolver);
ULONG ldap_compare_sA(LDAP *ld, const PSTR dn, const PSTR attr, PSTR value);
BOOL SetTimeZoneInformation(unknown_t *lpTimeZoneInformation);
SOCKET accept(SOCKET s, struct sockaddr *addr, int *addrlen);
int GetKeyNameTextA(LONG lParam, LPSTR lpString, int cchSize);
BOOL EnumTimeFormatsA(TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags);
VOID ApplicationRecoveryFinished(BOOL bSuccess);
long EnumPrinterKeyA(HPRINTER hPrinter, LPSTR pKeyName, LPSTR pSubkey, int cbSubkey, int *pcbSubkey);
BOOL CryptUpdateProtectedState(PSID pOldSid, LPCWSTR pwszOldPassword, DWORD dwFlags, DWORD *pdwSuccessCount, DWORD *pdwFailureCount);
INT WSAGetServiceClassInfoW(LPGUID lpProviderId, LPGUID lpServiceClassId, LPDWORD lpdwBufSize, LPWSASERVICECLASSINFOW lpServiceClassInfo);
DWORD GetSidLengthRequired(UCHAR nSubAuthorityCount);
VOID ldap_memfreeW(PWCHAR Block);
long EnumPrinterKeyW(HPRINTER hPrinter, LPWSTR pKeyName, LPWSTR pSubkey, int cbSubkey, int *pcbSubkey);
BOOL CryptDestroyKey(HCRYPTKEY hKey);
int CopyAcceleratorTableA(HACCEL hAccelSrc, LPACCEL lpAccelDst, int cAccelEntries);
BOOL GetBrushOrgEx(HDC hdc, LPPOINT lppt);
BOOL CancelDeviceWakeupRequest(HANDLE hDevice);
ULONG ldap_compare_sW(LDAP *ld, PWSTR dn, PWSTR attr, PWSTR value);
DWORD GetPriorityClass(HANDLE hProcess);
BOOL CertGetValidUsages(DWORD cCerts, PCCERT_CONTEXT *rghCerts, int *cNumOIDs, LPSTR *rghOIDs, DWORD *pcbOIDs);
time_t time(time_t *timer);
ULONG ldap_search_s(LDAP *ld, PSTR base, ULONG scope, PSTR filter, PZPSTR attrs, ULONG attrsonly, PLDAPMessage *res);
BOOL SetLocalTime(SYSTEMTIME *lpSystemTime);
BOOL GetAce(PACL pAcl, DWORD dwAceIndex, LPVOID *pAce);
BOOL IsThreadpoolTimerSet(PTP_TIMER pti);
VOID ldap_memfreeA(PCHAR Block);
HRESULT IsWow64GuestMachineSupported(USHORT WowGuestMachine, BOOL *MachineIsSupported);
BOOL ExecuteUmsThread(PUMS_CONTEXT UmsThread);
BOOL WaitForDebugEvent(unknown_t lpDebugEvent, DWORD dwMilliseconds);
BOOL IsWow64Message();
HWND GetDesktopWindow();
ULONG ldap_add_sA(LDAP *ld, PSTR dn, unknown_t **attrs);
ULONG ldap_parse_referenceA(LDAP *Connection, LDAPMessage *ResultMessage, PCHAR **Referrals);
double exp(double x);
int CopyAcceleratorTableW(HACCEL hAccelSrc, LPACCEL lpAccelDst, int cAccelEntries);
DWORD CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue, LPWSTR psz, DWORD csz);
ULONG QueryTraceProcessingHandle(TRACEHANDLE ProcessingHandle, ETW_PROCESS_HANDLE_INFO_TYPE InformationClass, PVOID InBuffer, ULONG InBufferSize, PVOID OutBuffer, ULONG OutBufferSize, PULONG ReturnLength);
DWORD GetDynamicTimeZoneInformation(PDYNAMIC_TIME_ZONE_INFORMATION pTimeZoneInformation);
BOOL GetGPOListA(HANDLE hToken, LPCSTR lpName, LPCSTR lpHostName, LPCSTR lpComputerName, DWORD dwFlags, PGROUP_POLICY_OBJECTA *pGPOList);
ULONG ldap_add_sW(LDAP *ld, PWSTR dn, unknown_t **attrs);
int mkstemp(char *template);
int feupdateenv(fenv_t *arg);
BOOL FlashWindowEx(PFLASHWINFO pfwi);
LPVOID GlobalWire(HGLOBAL hMem);
DWORD CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue, LPSTR psz, DWORD csz);
HRESULT RevokeActiveObject(DWORD dwRegister, void *pvReserved);
char * strlcpy(char *dest, const char *src, size_t  n);
int StringFromGUID2(REFGUID rguid, LPOLESTR lpsz, int cchMax);
ULONG ldap_parse_referenceW(LDAP *Connection, LDAPMessage *ResultMessage, PWCHAR **Referrals);
LPVOID MapViewOfFileEx(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress);
HRESULT VarImp(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
INT SystemTimeToVariantTime(LPSYSTEMTIME lpSystemTime, DOUBLE *pvtime);
BOOL SetPolyFillMode(HDC hdc, unknown_t iPolyFillMode);
HRESULT VarDecRound(LPDECIMAL pdecIn, int cDecimals, LPDECIMAL pdecResult);
HRESULT CoFileTimeNow(FILETIME *lpFileTime);
CONFIGRET CM_Get_HW_Prof_Flags_ExW(DEVINSTID_W pDeviceID, ULONG ulHardwareProfile, PULONG pulValue, ULONG ulFlags, HMACHINE hMachine);
VOID EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
BOOL AreFileApisANSI();
HRESULT VarBstrFromCy(unknown_t cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
BOOL DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime);
BOOL CryptSIPGetCaps(unknown_t *pSubjInfo, unknown_t *pCaps);
HRESULT DllUnregisterServer();
HRESULT VarCyCmp(unknown_t cyLeft, unknown_t cyRight);
BOOL GetGPOListW(HANDLE hToken, LPCWSTR lpName, LPCWSTR lpHostName, LPCWSTR lpComputerName, DWORD dwFlags, PGROUP_POLICY_OBJECTW *pGPOList);
BOOL IsCharUpperA(CHAR ch);
HRESULT VarDateFromDisp(unknown_t *pdispIn, LCID lcid, unknown_t *pdateOut);
BOOL GetClientRect(HWND hWnd, LPRECT lpRect);
BOOL CredGetTargetInfoW(LPCWSTR TargetName, DWORD Flags, PCREDENTIAL_TARGET_INFORMATIONW *TargetInfo);
BOOL GetSystemRegistryQuota(PDWORD pdwQuotaAllowed, PDWORD pdwQuotaUsed);
BOOL CryptGenKey(HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey);
CONFIGRET CM_Get_HW_Prof_Flags_ExA(DEVINSTID_A pDeviceID, ULONG ulHardwareProfile, PULONG pulValue, ULONG ulFlags, HMACHINE hMachine);
int getpid();
HRESULT PathCreateFromUrlW(PCWSTR pszUrl, PWSTR pszPath, DWORD *pcchPath, DWORD dwFlags);
BOOL OpenClipboard(HWND hWndNewOwner);
BOOL IsCharUpperW(WCHAR ch);
BOOL AddAccessDeniedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid);
BOOL GdiFlush();
HRESULT PathCreateFromUrlA(PCSTR pszUrl, PSTR pszPath, DWORD *pcchPath, DWORD dwFlags);
BOOL CredGetTargetInfoA(LPCSTR TargetName, DWORD Flags, PCREDENTIAL_TARGET_INFORMATIONA *TargetInfo);
HRESULT VarUI8FromUI4(ULONG ulIn, ULONG64 *pi64Out);
HRESULT VarUI8FromUI2(USHORT uiIn, ULONG64 *pi64Out);
BOOL DeregisterEventSource(HANDLE hEventLog);
BOOL GetProcessPriorityBoost(HANDLE hProcess, PBOOL pDisablePriorityBoost);
BOOL GetLogicalProcessorInformation(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, PDWORD ReturnedLength);
HRESULT VarUI8FromUI1(BYTE bIn, ULONG64 *pi64Out);
BOOL CryptImportKey(HCRYPTPROV hProv, BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey);
BOOL CredWriteDomainCredentialsW(PCREDENTIAL_TARGET_INFORMATIONW TargetInfo, PCREDENTIALW Credential, DWORD Flags);
HRESULT VarR4FromCy(unknown_t cyIn, FLOAT *pfltOut);
BOOL QueryActCtxSettingsW(DWORD dwFlags, HANDLE hActCtx, PCWSTR settingsNameSpace, PCWSTR settingName, PWSTR pvBuffer, SIZE_T dwBuffer, SIZE_T *pdwWrittenOrRequired);
ULONG ldap_control_freeA(LDAPControlA *Controls);
INT WSAEnumNameSpaceProvidersExW(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOEXW lpnspBuffer);
PCRYPT_ATTRIBUTE CertFindAttribute(LPCSTR pszObjId, DWORD cAttr, unknown_t *rgAttr);
ULONG TraceMessageVa(TRACEHANDLE LoggerHandle, ULONG MessageFlags, LPCGUID MessageGuid, USHORT MessageNumber, va_list MessageArgList);
BOOL UnhookWindowsHook(int nCode, HOOKPROC pfnFilterProc);
ULONG EventUnregister(REGHANDLE RegHandle);
VOID CertFreeCertificateChainList(PCCERT_CHAIN_CONTEXT *prgpSelection);
DWORD SubscribeServiceChangeNotifications(SC_HANDLE hService, unknown_t eEventType, unknown_t pCallback, PVOID pCallbackContext, unknown_t *pSubscription);
CONFIGRET CM_Request_Device_Eject_ExA(DEVINST dnDevInst, unknown_t pVetoType, LPSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine);
HRESULT VarBstrFromUI8(ULONG64 ui64In, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
BOOL CredWriteDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInfo, PCREDENTIALA Credential, DWORD Flags);
HDC ResetDCW(HDC hdc, unknown_t *lpInitData);
HRESULT VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
ULONG ldap_control_freeW(LDAPControlW *Control);
LRESULT CallNextHookEx(HHOOK hhk, int nCode, WPARAM wParam, LPARAM lParam);
HRESULT SHGetMalloc();
HRESULT VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
BOOL ReadFileScatter(HANDLE hFile, FILE_SEGMENT_ELEMENT *aSegmentArray, DWORD nNumberOfBytesToRead, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped);
void signal(int sig, void *func);
void * malloc(size_t size);
HRESULT VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
size_t strspn(const char *s1, const char *s2);
BOOL CryptImportPublicKeyInfoEx2(DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD dwFlags, void *pvAuxInfo, BCRYPT_KEY_HANDLE *phKey);
LPITEMIDLIST SHBrowseForFolderA();
BOOL CertVerifyCTLUsage(DWORD dwEncodingType, DWORD dwSubjectType, void *pvSubject, PCTL_USAGE pSubjectUsage, DWORD dwFlags, PCTL_VERIFY_USAGE_PARA pVerifyUsagePara, PCTL_VERIFY_USAGE_STATUS pVerifyUsageStatus);
BOOL ExpandEnvironmentStringsForUserW(HANDLE hToken, LPCWSTR lpSrc, LPWSTR lpDest, DWORD dwSize);
BOOL FillPath();
INT WSAEnumNameSpaceProvidersExA(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOEXA lpnspBuffer);
long AddFontResourceW();
BOOL RemoveSecureMemoryCacheCallback(PSECURE_MEMORY_CACHE_CALLBACK pfnCallBack);
CONFIGRET CM_Request_Device_Eject_ExW(DEVINST dnDevInst, unknown_t pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine);
HRESULT VarDecFromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, DECIMAL *pdecOut);
BOOL GetOsSafeBootMode(PDWORD Flags);
HDC ResetDCA(HDC hdc, unknown_t *lpInitData);
BOOL PathCompactPathA(HDC hDC, LPSTR pszPath, UINT dx);
WORD GetMaximumProcessorGroupCount();
LPITEMIDLIST SHBrowseForFolderW();
int vsprintf(char *s, const char *format, va_list arg);
BOOL ExpandEnvironmentStringsForUserA(HANDLE hToken, LPCSTR lpSrc, LPSTR lpDest, DWORD dwSize);
BOOL CertAddEncodedCertificateToSystemStoreW(LPCWSTR szCertStoreName, BYTE *pbCertEncoded, DWORD cbCertEncoded);
char * nl_langinfo(nl_item item);
BOOL HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);
void objc_enumerationMutation(void *instance);
long AddFontResourceA();
HRESULT VarDecDiv(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
BOOL SHCreateThread(LPTHREAD_START_ROUTINE pfnThreadProc, void *pData, unknown_t flags, LPTHREAD_START_ROUTINE pfnCallback);
BOOL PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb);
HRESULT VarI2FromDate(unknown_t dateIn, SHORT *psOut);
size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n);
BOOL PathCompactPathW(HDC hDC, LPWSTR pszPath, UINT dx);
BOOL SymGetSymbolFileW(HANDLE hProcess, PCWSTR SymPath, PCWSTR ImageFile, DWORD Type, PWSTR SymbolFile, size_t cSymbolFile, PWSTR DbgFile, size_t cDbgFile);
BOOL CertAddEncodedCertificateToSystemStoreA(LPCSTR szCertStoreName, BYTE *pbCertEncoded, DWORD cbCertEncoded);
BOOL CryptSIPRemoveSignedDataMsg(unknown_t *pSubjectInfo, DWORD dwIndex);
COLORREF ColorAdjustLuma(COLORREF clrRGB, int n, BOOL fScale);
char * initstate(uint32_t state, char *state, size_t size);
float fabsf(float x);
BOOL FreeGPOListA(PGROUP_POLICY_OBJECTA pGPOList);
ULONG ldap_create_page_controlW(PLDAP ExternalHandle, ULONG PageSize, struct berval *Cookie, UCHAR IsCritical, PLDAPControlW *Control);
BOOL ObjectDeleteAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose);
BOOL CredUnprotectA(BOOL fAsSelf, LPSTR pszProtectedCredentials, DWORD cchProtectedCredentials, LPSTR pszCredentials, DWORD *pcchMaxChars);
NTSTATUS BCryptEnumProviders(LPCWSTR pszAlgId, ULONG *pImplCount, unknown_t **ppImplList, ULONG dwFlags);
LSTATUS RegDeleteKeyValueW(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpValueName);
BOOL PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb);
long double fabsl(long double x);
HDESK GetThreadDesktop(DWORD dwThreadId);
HRESULT VarCyCmpR8(unknown_t cyLeft, double dblRight);
long ptrace(void *ptrace_request, pid_t pid, void *addr, void *data);
BOOL StartServiceCtrlDispatcherW(unknown_t *lpServiceStartTable);
BerElement * ber_alloc_t(INT options);
BOOL SetDlgItemInt(HWND hDlg, int nIDDlgItem, UINT uValue, BOOL bSigned);
BOOL WinHttpGetProxyForUrl(HINTERNET hSession, LPCWSTR lpcwszUrl, unknown_t *pAutoProxyOptions, unknown_t *pProxyInfo);
LSTATUS RegDeleteKeyValueA(HKEY hKey, LPCSTR lpSubKey, LPCSTR lpValueName);
ULONG ldap_create_page_controlA(PLDAP ExternalHandle, ULONG PageSize, struct berval *Cookie, UCHAR IsCritical, PLDAPControlA *Control);
char * strndup(const char *src, int n);
DWORD WinHttpResetAutoProxy(HINTERNET hSession, DWORD dwFlags);
DWORD PowerWriteDCValueIndex(HKEY RootPowerKey, GUID *SchemeGuid, GUID *SubGroupOfPowerSettingsGuid, GUID *PowerSettingGuid, DWORD DcValueIndex);
BOOL FreeGPOListW(PGROUP_POLICY_OBJECTW pGPOList);
BOOL CredUnprotectW(BOOL fAsSelf, LPWSTR pszProtectedCredentials, DWORD cchProtectedCredentials, LPWSTR pszCredentials, DWORD *pcchMaxChars);
HRESULT SHCreateItemFromParsingName(PCWSTR pszPath, unknown_t *pbc, REFIID riid, void **ppv);
BOOL FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData);
BOOL SetPixelFormat(HDC hdc, int iPixelFormat, unknown_t *ppfd);
HRESULT AVIFileInfoW(unknown_t pfile, unknown_t pfi, LONG lSize);
BOOL ObjectDeleteAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose);
HRESULT StrFormatByteSizeEx(ULONGLONG ull, unknown_t flags, PWSTR pszBuf, UINT cchBuf);
int fsetpos(FILE *stream, fpos_t *pos);
BOOL CreatePrivateObjectSecurityEx(PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR *NewDescriptor, GUID *ObjectType, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping);
BOOL EndDeferWindowPos(HDWP hWinPosInfo);
BOOL CryptEnumKeyIdentifierProperties(unknown_t *pKeyIdentifier, DWORD dwPropId, DWORD dwFlags, LPCWSTR pwszComputerName, void *pvReserved, void *pvArg, PFN_CRYPT_ENUM_KEYID_PROP pfnEnum);
BOOL StartServiceCtrlDispatcherA(unknown_t *lpServiceStartTable);
HRESULT AVIFileInfoA(unknown_t pfile, unknown_t pfi, LONG lSize);
CONFIGRET CM_Get_Next_Res_Des(PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource, PRESOURCEID pResourceID, ULONG ulFlags);
HRESULT VarUI1FromCy(unknown_t cyIn, BYTE *pbOut);
INT WSAEnumNameSpaceProvidersA(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOA lpnspBuffer);
VOID RtlRestoreContext(PCONTEXT ContextRecord, struct _EXCEPTION_RECORD *ExceptionRecord);
ULONG ldap_delete_extA(LDAP *ld, const PSTR dn, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
HRESULT CoGetCallContext(REFIID riid, void **ppInterface);
HICON ExtractAssociatedIconExA(HINSTANCE hInst, LPSTR pszIconPath, WORD *piIconIndex, WORD *piIconId);
HRESULT SHGetStockIconInfo(unknown_t siid, UINT uFlags, unknown_t *psii);
int DrawTextW(HDC hdc, LPCWSTR lpchText, int cchText, LPRECT lprc, UINT format);
BOOL IsNativeVhdBoot(PBOOL NativeVhdBoot);
HICON ExtractAssociatedIconExW(HINSTANCE hInst, LPWSTR pszIconPath, WORD *piIconIndex, WORD *piIconId);
BOOL SymGetSymFromName(HANDLE hProcess, PCSTR Name, PIMAGEHLP_SYMBOL Symbol);
ULONG ldap_delete_extW(LDAP *ld, PWSTR dn, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, ULONG *MessageNumber);
ULONG TraceMessage(TRACEHANDLE LoggerHandle, ULONG MessageFlags, LPCGUID MessageGuid, USHORT MessageNumber, unknown_t ...);
HRESULT VarR4FromI8(LONG64 i64In, FLOAT *pfltOut);
INT WSAEnumNameSpaceProvidersW(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOW lpnspBuffer);
char * strstr(const char *s1, const char *s2);
UINT GetSystemDpiForProcess(HANDLE hProcess);
int DrawTextA(HDC hdc, LPCSTR lpchText, int cchText, LPRECT lprc, UINT format);
LONG QueryDisplayConfig(UINT32 flags, UINT32 *numPathArrayElements, unknown_t *pathArray, UINT32 *numModeInfoArrayElements, unknown_t *modeInfoArray, DISPLAYCONFIG_TOPOLOGY_ID *currentTopologyId);
void quick_exit(int status);
HRESULT VarR4FromI1(CHAR cIn, FLOAT *pfltOut);
VOID CloseThreadpoolWork(PTP_WORK pwk);
HRESULT CoRegisterMessageFilter(unknown_t lpMessageFilter, unknown_t *lplpMessageFilter);
HRESULT VarR4FromI2(SHORT sIn, FLOAT *pfltOut);
PWSTR StrRChrIW(PCWSTR pszStart, PCWSTR pszEnd, WCHAR wMatch);
BOOL GetThreadPriorityBoost(HANDLE hThread, PBOOL pDisablePriorityBoost);
CONFIGRET CM_Query_Remove_SubTree(DEVINST dnAncestor, ULONG ulFlags);
BOOL SystemParametersInfoForDpi(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni, UINT dpi);
HRESULT VarR4FromI4(LONG lIn, FLOAT *pfltOut);
ULONG ldap_add_s(LDAP *ld, PSTR dn, unknown_t **attrs);
CONFIGRET CM_Set_HW_Prof_Ex(ULONG ulHardwareProfile, ULONG ulFlags, HMACHINE hMachine);
DWORD SetSecurityDescriptorRMControl(PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl);
BOOLEAN EventEnabled(REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor);
BOOL GetSystemTimeAdjustmentPrecise(PDWORD64 lpTimeAdjustment, PDWORD64 lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled);
DWORD64 SymLoadModule64(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll);
PSTR StrRChrIA(PCSTR pszStart, PCSTR pszEnd, WORD wMatch);
BOOL SymGetSourceFileW(HANDLE hProcess, ULONG64 Base, PCWSTR Params, PCWSTR FileSpec, PWSTR FilePath, DWORD Size);
BOOL GetCPInfoExW(UINT CodePage, DWORD dwFlags, LPCPINFOEXW lpCPInfoEx);
BOOL GetProcessGroupAffinity(HANDLE hProcess, PUSHORT GroupCount, PUSHORT GroupArray);
DWORD GetCurrentThreadId();
HMETAFILE CopyMetaFileW(HMETAFILE hmfSrc, LPCWSTR lpszFile);
BOOL GetDCOrgEx(HDC hdc, LPPOINT lpPoint);
HRESULT CoGetPSClsid(REFIID riid, unknown_t *pClsid);
LPVOID LockResource(HGLOBAL hResData);
BOOL GetCPInfoExA(UINT CodePage, DWORD dwFlags, LPCPINFOEXA lpCPInfoEx);
HRESULT VarFormatDateTime(LPVARIANT pvarIn, int iNamedFormat, ULONG dwFlags, BSTR *pbstrOut);
BOOL SetConsoleMode(HANDLE hConsoleHandle, DWORD dwMode);
BOOL DeleteAce(PACL pAcl, DWORD dwAceIndex);
HMETAFILE CopyMetaFileA(HMETAFILE hmfSrc, LPCSTR lpszFile);
BOOL SetCommMask(HANDLE hFile, DWORD dwEvtMask);
LRESULT DefDlgProcA(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL CryptRegisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszDll, LPCSTR pszOverrideFuncName);
void srand(int seed);
CONFIGRET CM_Get_Class_Key_NameA(LPGUID ClassGuid, LPSTR pszKeyName, PULONG pulLength, ULONG ulFlags);
int WSASendDisconnect(SOCKET s, LPWSABUF lpOutboundDisconnectData);
HRESULT VarR4FromDate(unknown_t dateIn, FLOAT *pfltOut);
LRESULT DefDlgProcW(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam);
HLOCAL LocalHandle(LPCVOID pMem);
HRESULT VarDecFromR4(FLOAT fltIn, DECIMAL *pdecOut);
VOID ReleaseSemaphoreWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, HANDLE sem, DWORD crel);
HFILE OpenFile(LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle);
ULONG ldap_rename_ext_s(LDAP *ld, const PSTR dn, const PSTR NewRDN, const PSTR NewParent, INT DeleteOldRdn, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
WORD SetClassWord(HWND hWnd, int nIndex, WORD wNewWord);
BOOL SymDeleteSymbolW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Name, DWORD64 Address, DWORD Flags);
BOOL InjectTouchInput(UINT32 count, unknown_t *contacts);
HANDLE WSAAsyncGetServByName(HWND hWnd, u_int wMsg, const char *name, const char *proto, char *buf, int buflen);
BOOL GetVersionExW(unknown_t lpVersionInformation);
UINT GetRegisteredRawInputDevices(PRAWINPUTDEVICE pRawInputDevices, PUINT puiNumDevices, UINT cbSize);
BOOL SetScrollRange(HWND hWnd, int nBar, int nMinPos, int nMaxPos, BOOL bRedraw);
CONFIGRET CM_Get_Class_Key_NameW(LPGUID ClassGuid, LPWSTR pszKeyName, PULONG pulLength, ULONG ulFlags);
HRESULT VarDecFromR8(DOUBLE dblIn, DECIMAL *pdecOut);
BOOL WritePrivateProfileStructA(LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile);
HRESULT VarBstrFromI8(LONG64 i64In, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
HRESULT VarUI1FromDisp(unknown_t *pdispIn, LCID lcid, BYTE *pbOut);
SECURITY_STATUS NCryptStreamOpenToUnprotect(unknown_t *pStreamInfo, DWORD dwFlags, HWND hWnd, NCRYPT_STREAM_HANDLE *phStream);
BOOL CoFileTimeToDosDateTime(FILETIME *lpFileTime, LPWORD lpDosDate, LPWORD lpDosTime);
BOOL GetVersionExA(LPOSVERSIONINFOA lpVersionInformation);
HRESULT VarUI1FromDec(DECIMAL *pdecIn, BYTE *pbOut);
DWORD GetMappedFileNameW(HANDLE hProcess, LPVOID lpv, LPWSTR lpFilename, DWORD nSize);
INT SysReAllocStringLen(BSTR *pbstr, unknown_t *psz, unsigned int len);
HRESULT VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
int PathGetDriveNumberW(LPCWSTR pszPath);
HPALETTE CreatePalette();
int scanf(const char *format);
HRESULT VarBstrFromI2(SHORT iVal, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
HWND GetActiveWindow();
BOOL SetWindowPlacement(HWND hWnd, unknown_t *lpwndpl);
HRESULT VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
BOOL AttachConsole(DWORD dwProcessId);
BOOL GetCurrentHwProfileA(LPHW_PROFILE_INFOA lpHwProfileInfo);
BOOL ImageList_Destroy(HIMAGELIST himl);
HBITMAP CreateMappedBitmap(HINSTANCE hInstance, INT_PTR idBitmap, UINT wFlags, LPCOLORMAP lpColorMap, int iNumMaps);
BOOL WritePrivateProfileStructW(LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile);
int PathGetDriveNumberA(LPCSTR pszPath);
NTSTATUS BCryptEncrypt(BCRYPT_KEY_HANDLE hKey, PUCHAR pbInput, ULONG cbInput, VOID *pPaddingInfo, PUCHAR pbIV, ULONG cbIV, PUCHAR pbOutput, ULONG cbOutput, ULONG *pcbResult, ULONG dwFlags);
BOOL CertVerifyCRLRevocation(DWORD dwCertEncodingType, PCERT_INFO pCertId, DWORD cCrlInfo, PCRL_INFO *rgpCrlInfo);
BOOL GetCurrentHwProfileW(LPHW_PROFILE_INFOW lpHwProfileInfo);
DWORD GetMappedFileNameA(HANDLE hProcess, LPVOID lpv, LPSTR lpFilename, DWORD nSize);
HRESULT SHEvaluateSystemCommandTemplate(PCWSTR pszCmdTemplate, PWSTR *ppszApplication, PWSTR *ppszCommandLine, PWSTR *ppszParameters);
DWORD CryptMsgCalculateEncodedLength(DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID, DWORD cbData);
UINT GetDoubleClickTime();
HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName);
BOOL PolylineTo(HDC hdc, POINT *lppt, DWORD cCount);
UINT PrivateExtractIconsW(LPCWSTR szFileName, int nIconIndex, int cxIcon, int cyIcon, HICON *phicon, UINT *piconid, UINT nIcons, UINT flags);
CONFIGRET CM_Merge_Range_List(unknown_t rlhOld1, unknown_t rlhOld2, unknown_t rlhNew, ULONG ulFlags);
BOOL SymEnumerateModules(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACK EnumModulesCallback, PVOID UserContext);
PWSTR StrFormatByteSizeW(LONGLONG qdw, PWSTR pszBuf, UINT cchBuf);
BOOL SetFileValidData(HANDLE hFile, LONGLONG ValidDataLength);
HANDLE FindDebugInfoFileEx(PCSTR FileName, PCSTR SymbolPath, PSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACK Callback, PVOID CallerData);
BOOL EnumCalendarInfoExW(CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType);
HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName);
HGDIOBJ GetStockObject();
HBRUSH CreateDIBPatternBrushPt(VOID *lpPackedDIB, unknown_t iUsage);
UINT PrivateExtractIconsA(LPCSTR szFileName, int nIconIndex, int cxIcon, int cyIcon, HICON *phicon, UINT *piconid, UINT nIcons, UINT flags);
int WPUOpenCurrentThread(LPWSATHREADID lpThreadId, LPINT lpErrno);
DWORD WaitServiceState(SC_HANDLE hService, DWORD dwNotify, DWORD dwTimeout, HANDLE hCancelEvent);
HRESULT CoGetStandardMarshal(REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags, LPMARSHAL *ppMarshal);
double nexttoward(double x, long double y);
HENHMETAFILE GetEnhMetaFileA();
HRESULT HashData(BYTE *pbData, DWORD cbData, BYTE *pbHash, DWORD cbHash);
PCCERT_CHAIN_CONTEXT CertFindChainInStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, DWORD dwFindFlags, DWORD dwFindType, const void *pvFindPara, PCCERT_CHAIN_CONTEXT pPrevChainContext);
PSTR StrFormatByteSizeA(DWORD dw, PSTR pszBuf, UINT cchBuf);
BOOL GetViewportExtEx(HDC hdc, LPSIZE lpSize);
BOOL CloseClipboard();
CONFIGRET CM_Request_Eject_PC_Ex(HMACHINE hMachine);
wchar_t * wcspbrk(wchar_t *s1, wchar_t *s2);
BOOL LookupAccountSidLocalW(PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
HRESULT VarI8FromUI8(ULONG64 ui64In, LONG64 *pi64Out);
HANDLE FindFirstStreamTransactedW(LPCWSTR lpFileName, STREAM_INFO_LEVELS InfoLevel, LPVOID lpFindStreamData, DWORD dwFlags, HANDLE hTransaction);
VOID CloseEncryptedFileRaw(PVOID pvContext);
BOOL EnumCalendarInfoExA(CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx, LCID Locale, CALID Calendar, CALTYPE CalType);
BOOL LockWorkStation();
HRESULT VarI8FromUI2(USHORT uiIn, LONG64 *pi64Out);
HRESULT VarI8FromUI1(BYTE bIn, LONG64 *pi64Out);
int unlink(const char *path);
INT WSASetSocketPeerTargetName(SOCKET Socket, unknown_t *PeerTargetName, ULONG PeerTargetNameLen, LPWSAOVERLAPPED Overlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine);
HENHMETAFILE GetEnhMetaFileW();
BOOL SymSetContext(HANDLE hProcess, PIMAGEHLP_STACK_FRAME StackFrame, PIMAGEHLP_CONTEXT Context);
int StrCmpNCA(LPCSTR pszStr1, LPCSTR pszStr2, int nChar);
BOOL DeletePrinter();
HRESULT VarI8FromUI4(ULONG ulIn, LONG64 *pi64Out);
BOOL PathAppendA(LPSTR pszPath, LPCSTR pszMore);
int WSACancelBlockingCall();
ULONG ldap_searchA(LDAP *ld, const PSTR base, ULONG scope, const PSTR filter, PZPSTR attrs, ULONG attrsonly);
BOOL PhysicalToLogicalPoint(HWND hWnd, LPPOINT lpPoint);
int mblen(const char *s, size_t n);
BOOL LookupAccountSidLocalA(PSID Sid, LPSTR Name, LPDWORD cchName, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
DWORD SetClassLongA(HWND hWnd, int nIndex, LONG dwNewLong);
BOOL ConvertSecurityDescriptorToStringSecurityDescriptorW(PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD RequestedStringSDRevision, SECURITY_INFORMATION SecurityInformation, LPWSTR *StringSecurityDescriptor, PULONG StringSecurityDescriptorLen);
BOOL RegisterWaitForSingleObject(PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags);
BOOL PathAppendW(LPWSTR pszPath, LPCWSTR pszMore);
BOOL GetICMProfileW(HDC hDC, LPDWORD lpcbName, LPWSTR lpszFilename);
BOOL SymEnumerateSymbols(HANDLE hProcess, ULONG BaseOfDll, PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
BOOL SymGetSourceFileFromToken(HANDLE hProcess, PVOID Token, PCSTR Params, PSTR FilePath, DWORD Size);
BOOL InetIsOffline();
HRESULT SetCurrentProcessExplicitAppUserModelID(PCWSTR AppID);
BOOL WSASetEvent(WSAEVENT hEvent);
ULONG ldap_searchW(LDAP *ld, PWSTR base, ULONG scope, PWSTR filter, PZPWSTR attrs, ULONG attrsonly);
int StrCmpNCW(LPCWSTR pszStr1, LPCWSTR pszStr2, int nChar);
HANDLE SHAllocShared(const void *pvData, DWORD dwSize, DWORD dwProcessId);
BOOL GetWsChangesEx(HANDLE hProcess, PPSAPI_WS_WATCH_INFORMATION_EX lpWatchInfoEx, PDWORD cb);
BOOL AnimateWindow(HWND hWnd, DWORD dwTime, DWORD dwFlags);
BOOL SetThreadpoolStackInformation(PTP_POOL ptpp, PTP_POOL_STACK_INFORMATION ptpsi);
DWORD SetClassLongW(HWND hWnd, int nIndex, LONG dwNewLong);
BOOL ConvertSecurityDescriptorToStringSecurityDescriptorA(PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD RequestedStringSDRevision, SECURITY_INFORMATION SecurityInformation, LPSTR *StringSecurityDescriptor, PULONG StringSecurityDescriptorLen);
BOOL RevertToSelf();
BOOL CopyFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists);
BOOL CryptDestroyHash(HCRYPTHASH hHash);
BOOL GetICMProfileA(HDC hDC, LPDWORD lpcbName, LPSTR lpszFilename);
BOOL AreAnyAccessesGranted(DWORD GrantedAccess, DWORD DesiredAccess);
BOOL CryptExportPublicKeyInfo(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey, DWORD dwKeySpec, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
HRESULT CoCreateInstanceFromApp(unknown_t Clsid, IUnknown *punkOuter, DWORD dwClsCtx, PVOID reserved, DWORD dwCount, unknown_t *pResults);
BOOL CopyFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists);
BOOL AccessCheckAndAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose);
BOOL SetWaitableTimer(HANDLE hTimer, LARGE_INTEGER *lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume);
DWORD GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer);
int WSCInstallProviderAndChains64_32(LPGUID lpProviderId, LPWSTR lpszProviderDllPath, LPWSTR lpszProviderDllPath32, LPWSTR lpszLspName, DWORD dwServiceFlags, LPWSAPROTOCOL_INFOW lpProtocolInfoList, DWORD dwNumberOfEntries, LPDWORD lpdwCatalogEntryId, LPINT lpErrno);
BOOL DeletePrinterDataA(HPRINTER hPrinter, LPSTR pValueName);
int SetMetaRgn();
ULONG ldap_parse_result(LDAP *Connection, LDAPMessage *ResultMessage, ULONG *ReturnCode, PSTR *MatchedDNs, PSTR *ErrorMessage, PSTR **Referrals, PLDAPControlA **ServerControls, BOOLEAN Freeit);
bool islessequal(double x, double y);
HRESULT MkParseDisplayName(unknown_t pbc, LPCOLESTR szUserName, ULONG *pchEaten, unknown_t *ppmk);
BOOL AccessCheckAndAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose);
DWORD GetFileType(HANDLE hFile);
BOOL SHGetSpecialFolderPathW(HWND hwndOwner, LPWSTR lpszPath, unknown_t nFolder, BOOL fCreate);
DWORD GetLongPathNameA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer);
PCERT_RDN_ATTR CertFindRDNAttr(LPCSTR pszObjId, PCERT_NAME_INFO pName);
CONFIGRET CM_Set_HW_Prof_Flags_ExA(DEVINSTID_A pDeviceID, ULONG ulConfig, ULONG ulValue, ULONG ulFlags, HMACHINE hMachine);
BOOL FindCloseChangeNotification(HANDLE hChangeHandle);
HCERTSTORE CertOpenStore(LPCSTR lpszStoreProvider, DWORD dwEncodingType, HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const void *pvPara);
HRESULT OleTranslateColor(OLE_COLOR clr, HPALETTE hpal, COLORREF *lpcolorref);
HRESULT CreateAppContainerProfile(PCWSTR pszAppContainerName, PCWSTR pszDisplayName, PCWSTR pszDescription, PSID_AND_ATTRIBUTES pCapabilities, DWORD dwCapabilityCount, PSID *ppSidAppContainerSid);
DWORD CertEnumCTLContextProperties(PCCTL_CONTEXT pCtlContext, DWORD dwPropId);
BOOL DeletePrinterDataW(HPRINTER hPrinter, LPWSTR pValueName);
BOOL DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
BOOL SHGetSpecialFolderPathA(HWND hwndOwner, LPSTR lpszPath, unknown_t nFolder, BOOL fCreate);
HRESULT CopyFile2(PCWSTR pwszExistingFileName, PCWSTR pwszNewFileName, unknown_t *pExtendedParameters);
INT GetAddrInfoExOverlappedResult(LPOVERLAPPED lpOverlapped);
VOID LeaveCriticalSectionWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, PCRITICAL_SECTION pcs);
HCERTSTORE CertOpenSystemStoreA(HCRYPTPROV_LEGACY hProv, LPCSTR szSubsystemProtocol);
PCHAR ldap_err2string(ULONG err);
BOOL K32EnumProcessModulesEx(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded, DWORD dwFilterFlag);
BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
CONFIGRET CM_Set_HW_Prof_Flags_ExW(DEVINSTID_W pDeviceID, ULONG ulConfig, ULONG ulValue, ULONG ulFlags, HMACHINE hMachine);
BOOL LPtoDP(HDC hdc, LPPOINT lpPoints, int nCount);
HRESULT SHCreateStreamOnFileEx(LPCWSTR pszFile, DWORD grfMode, DWORD dwAttributes, BOOL fCreate, struct IStream *pstmTemplate, struct IStream **ppstm);
LPWSTR CharUpperW(LPWSTR lpsz);
INT SetAddrInfoExA(PCSTR pName, PCSTR pServiceName, unknown_t *pAddresses, DWORD dwAddressCount, LPBLOB lpBlob, DWORD dwFlags, DWORD dwNameSpace, LPGUID lpNspId, struct timeval *timeout, LPOVERLAPPED lpOverlapped, unknown_t lpCompletionRoutine, LPHANDLE lpNameHandle);
HCERTSTORE CertOpenSystemStoreW(HCRYPTPROV_LEGACY hProv, LPCWSTR szSubsystemProtocol);
BOOL SetupComm(HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue);
HANDLE OpenWaitableTimerW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName);
int WSCInstallProviderAndChains(LPGUID lpProviderId, LPWSTR lpszProviderDllPath, LPWSTR lpszLspName, DWORD dwServiceFlags, LPWSAPROTOCOL_INFOW lpProtocolInfoList, DWORD dwNumberOfEntries, LPDWORD lpdwCatalogEntryId, LPINT lpErrno);
HRESULT VarCyFromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, unknown_t *pcyOut);
INT ldap_sasl_bindW(LDAP *ExternalHandle, PWSTR DistName, PWSTR AuthMechanism, BERVAL *cred, PLDAPControlW *ServerCtrls, PLDAPControlW *ClientCtrls, int *MessageNumber);
BOOL SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line);
INT SetAddrInfoExW(PCWSTR pName, PCWSTR pServiceName, unknown_t *pAddresses, DWORD dwAddressCount, LPBLOB lpBlob, DWORD dwFlags, DWORD dwNameSpace, LPGUID lpNspId, struct timeval *timeout, LPOVERLAPPED lpOverlapped, unknown_t lpCompletionRoutine, LPHANDLE lpNameHandle);
DWORD GetGlyphOutlineW(HDC hdc, UINT uChar, unknown_t uFormat, unknown_t lpgm, DWORD cbBuffer, LPVOID lpvBuffer, unknown_t *lpmat2);
BOOL EnumResourceNamesExW(HMODULE hModule, LPCWSTR lpType, unknown_t lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
HRESULT UnRegisterTypeLibForUser(REFGUID libID, WORD wMajorVerNum, WORD wMinorVerNum, LCID lcid, unknown_t syskind);
int open(const char *path, int oflag);
INT ldap_sasl_bindA(LDAP *ExternalHandle, const PSTR DistName, const PSTR AuthMechanism, BERVAL *cred, PLDAPControlA *ServerCtrls, PLDAPControlA *ClientCtrls, int *MessageNumber);
DWORD GetGlyphOutlineA(HDC hdc, UINT uChar, unknown_t uFormat, unknown_t lpgm, DWORD cbBuffer, LPVOID lpvBuffer, unknown_t *lpmat2);
LPSTR CharUpperA(LPSTR lpsz);
BOOL SHFreeShared(HANDLE hData, DWORD dwProcessId);
CONFIGRET CM_Get_Hardware_Profile_InfoA(ULONG ulIndex, unknown_t pHWProfileInfo, ULONG ulFlags);
VOID DeleteBoundaryDescriptor(HANDLE BoundaryDescriptor);
HANDLE OpenWaitableTimerA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName);
HRESULT VarCyFromR8(DOUBLE dblIn, unknown_t *pcyOut);
HRESULT VarCyFromR4(FLOAT fltIn, unknown_t *pcyOut);
BOOL SymUnDName64(PIMAGEHLP_SYMBOL64 sym, PSTR UnDecName, DWORD UnDecNameLength);
BOOL LoadUserProfileW(HANDLE hToken, LPPROFILEINFOW lpProfileInfo);
int usleep(int s);
BOOL EnumResourceNamesExA(HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROCA lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
CONFIGRET CM_Get_Hardware_Profile_InfoW(ULONG ulIndex, unknown_t pHWProfileInfo, ULONG ulFlags);
BOOL GetCommProperties(HANDLE hFile, LPCOMMPROP lpCommProp);
BOOL AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus);
BOOLEAN CreateSymbolicLinkTransactedA(LPCSTR lpSymlinkFileName, LPCSTR lpTargetFileName, DWORD dwFlags, HANDLE hTransaction);
BOOL WriteConsoleA(HANDLE hConsoleOutput, VOID *lpBuffer, DWORD nNumberOfCharsToWrite, LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved);
BOOL GetThreadSelectorEntry(HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry);
ULONG ldap_modrdn2(LDAP *ExternalHandle, const PSTR DistinguishedName, const PSTR NewDistinguishedName, INT DeleteOldRdn);
HHOOK SetWindowsHookExA(int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId);
BOOL LoadUserProfileA(HANDLE hToken, LPPROFILEINFOA lpProfileInfo);
HRESULT CoGetCurrentLogicalThreadId(GUID *pguid);
BOOL EnumResourceNamesA(HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROCA lpEnumFunc, LONG_PTR lParam);
int wvnsprintfA(PSTR pszDest, int cchDest, PCSTR pszFmt, va_list arglist);
DWORD InSendMessageEx(LPVOID lpReserved);
BOOL WriteConsoleW(HANDLE hConsoleOutput, VOID *lpBuffer, DWORD nNumberOfCharsToWrite, LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved);
HRESULT SHGetFolderLocation(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl);
int setsockopt(SOCKET s, int level, int optname, const char *optval, int optlen);
HHOOK SetWindowsHookExW(int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId);
BOOL AddAccessDeniedObjectAce(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID *ObjectTypeGuid, GUID *InheritedObjectTypeGuid, PSID pSid);
BOOL CryptExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
int FindNLSString(LCID Locale, DWORD dwFindNLSStringFlags, LPCWSTR lpStringSource, int cchSource, LPCWSTR lpStringValue, int cchValue, LPINT pcchFound);
BOOL GetAppContainerNamedObjectPath(HANDLE Token, PSID AppContainerSid, ULONG ObjectPathLength, LPWSTR ObjectPath, PULONG ReturnLength);
LPWSTR GetCommandLineW();
BOOL ImageList_DrawIndirect(unknown_t *pimldp);
int wvnsprintfW(PWSTR pszDest, int cchDest, PCWSTR pszFmt, va_list arglist);
HRESULT AVIFileOpenA(unknown_t *ppfile, LPCSTR szFile, UINT mode, unknown_t pclsidHandler);
BOOLEAN CreateSymbolicLinkTransactedW(LPCWSTR lpSymlinkFileName, LPCWSTR lpTargetFileName, DWORD dwFlags, HANDLE hTransaction);
BOOL CredWriteA(PCREDENTIALA Credential, DWORD Flags);
ULONG EventWriteEx(REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor, ULONG64 Filter, ULONG Flags, LPCGUID ActivityId, LPCGUID RelatedActivityId, ULONG UserDataCount, PEVENT_DATA_DESCRIPTOR UserData);
ULONG ldap_modrdn(LDAP *ExternalHandle, const PSTR DistinguishedName, const PSTR NewDistinguishedName);
DWORD GetProcessVersion(DWORD ProcessId);
DWORD GetProfileStringA(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize);
HRESULT DispGetParam(unknown_t *pdispparams, UINT position, VARTYPE vtTarg, VARIANT *pvarResult, UINT *puArgErr);
BOOL VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect);
int iswpunct(wint_t wc);
BOOL PathFindOnPathA(LPSTR pszPath, unknown_t ppszOtherDirs);
BOOL EnumResourceNamesW(HMODULE hModule, LPCWSTR lpType, unknown_t lpEnumFunc, LONG_PTR lParam);
SC_HANDLE OpenServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, DWORD dwDesiredAccess);
HICON ExtractAssociatedIconW(HINSTANCE hInst, LPWSTR pszIconPath, WORD *piIcon);
HMENU CreatePopupMenu();
BOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID *pSid);
LPSTR GetCommandLineA();
float sinf(float x);
lldiv_t lldiv(long long numer, long long denom);
HRESULT GetAcceptLanguagesW(LPWSTR pszLanguages, DWORD *pcchLanguages);
BOOL GetMailslotInfo(HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout);
DWORD SetMapperFlags(HDC hdc, DWORD dwFlag);
double sinh(double x);
CONFIGRET CM_Get_DevNode_Status_Ex(PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
HRESULT RevokeScaleChangeNotifications(DISPLAY_DEVICE_TYPE displayDevice, DWORD dwCookie);
VOID RtlUnwind(PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue);
DWORD GetConsoleTitleA(LPSTR lpConsoleTitle, DWORD nSize);
VOID CryptMemFree(LPVOID pv);
HRESULT AVIFileOpenW(unknown_t *ppfile, LPCWSTR szFile, UINT mode, unknown_t pclsidHandler);
long double sinl(long double x);
DWORD GetProfileStringW(LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize);
BOOL RemoveDirectoryA(LPCSTR lpPathName);
BOOL CredWriteW(PCREDENTIALW Credential, DWORD Flags);
BOOL Rectangle(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
HWND CreateStatusWindowW(LONG style, LPCWSTR lpszText, HWND hwndParent, UINT wID);
BOOL ReadConsoleInputW(HANDLE hConsoleInput, PINPUT_RECORD lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead);
SC_HANDLE OpenServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, DWORD dwDesiredAccess);
HICON ExtractAssociatedIconA(HINSTANCE hInst, LPSTR pszIconPath, WORD *piIcon);
HRESULT CoUnmarshalHresult(LPSTREAM pstm, HRESULT *phresult);
HRESULT GetAcceptLanguagesA(LPSTR pszLanguages, DWORD *pcchLanguages);
BOOL PathFindOnPathW(LPWSTR pszPath, unknown_t ppszOtherDirs);
int GetDurationFormatEx(LPCWSTR lpLocaleName, DWORD dwFlags, SYSTEMTIME *lpDuration, ULONGLONG ullDuration, LPCWSTR lpFormat, LPWSTR lpDurationStr, int cchDuration);
HWND CreateStatusWindowA(LONG style, LPCSTR lpszText, HWND hwndParent, UINT wID);
DWORD GetConsoleTitleW(LPWSTR lpConsoleTitle, DWORD nSize);
BOOL RemoveDirectoryW(LPCWSTR lpPathName);
LANGID GetUserDefaultLangID();
HRESULT TaskDialogIndirect(unknown_t *pTaskConfig, int *pnButton, int *pnRadioButton, BOOL *pfVerificationFlagChecked);
HRESULT CoQueryAuthenticationServices(DWORD *pcAuthSvc, unknown_t **asAuthSvc);
LDAP * ldap_sslinitW(PWSTR HostName, ULONG PortNumber, int secure);
BOOL ReadConsoleInputA(HANDLE hConsoleInput, PINPUT_RECORD lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead);
BOOL ActivateActCtx(HANDLE hActCtx, ULONG_PTR *lpCookie);
BOOL UnregisterBadMemoryNotification(PVOID RegistrationHandle);
HRESULT VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
void * calloc(size_t nmeb, size_t size);
BOOL PathUnmakeSystemFolderA(LPCSTR pszPath);
HRESULT VarBstrFromR8(DOUBLE dblIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
CONFIGRET CM_Register_Device_Driver(DEVINST dnDevInst, ULONG ulFlags);
CONFIGRET CM_Dup_Range_List(unknown_t rlhOld, unknown_t rlhNew, ULONG ulFlags);
PCHAR * ldap_explode_dn(const PSTR dn, ULONG notypes);
HRESULT VariantChangeType(unknown_t *pvargDest, unknown_t *pvarSrc, USHORT wFlags, VARTYPE vt);
BOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent, PACL pSacl, BOOL bSaclDefaulted);
DWORD MsgWaitForMultipleObjects(DWORD nCount, HANDLE *pHandles, BOOL fWaitAll, DWORD dwMilliseconds, DWORD dwWakeMask);
BOOL IsBadStringPtrW(LPCWSTR lpsz, UINT_PTR ucchMax);
LDAP * ldap_sslinitA(PSTR HostName, ULONG PortNumber, int secure);
BOOL WinHttpCheckPlatform();
BOOL SetVolumeLabelA(LPCSTR lpRootPathName, LPCSTR lpVolumeName);
LPVOID CreateEnclave(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, SIZE_T dwInitialCommitment, DWORD flEnclaveType, LPCVOID lpEnclaveInformation, DWORD dwInfoLength, LPDWORD lpEnclaveError);
BOOL SetVolumeMountPointA(LPCSTR lpszVolumeMountPoint, LPCSTR lpszVolumeName);
void SHFreeNameMappings(HANDLE hNameMappings);
SECURITY_STATUS NCryptDeleteKey(NCRYPT_KEY_HANDLE hKey, DWORD dwFlags);
long double expl(long double x);
BOOL PathUnmakeSystemFolderW(LPCWSTR pszPath);
ULONG ldap_modrdnW(LDAP *ExternalHandle, PWSTR DistinguishedName, PWSTR NewDistinguishedName);
BOOL ShowCaret(HWND hWnd);
HRESULT PathCchStripToRoot(PWSTR pszPath, size_t cchPath);
BOOL GetScrollInfo(HWND hwnd, int nBar, LPSCROLLINFO lpsi);
BOOL IsBadStringPtrA(LPCSTR lpsz, UINT_PTR ucchMax);
UINT GetDpiForWindow(HWND hwnd);
int DrawTextExA(HDC hdc, LPSTR lpchText, int cchText, LPRECT lprc, UINT format, LPDRAWTEXTPARAMS lpdtp);
DWORD PowerSettingUnregisterNotification(HPOWERNOTIFY RegistrationHandle);
ULONG ldap_parse_resultA(LDAP *Connection, LDAPMessage *ResultMessage, ULONG *ReturnCode, PSTR *MatchedDNs, PSTR *ErrorMessage, PZPSTR *Referrals, PLDAPControlA **ServerControls, BOOLEAN Freeit);
BOOL EqualRect(RECT *lprc1, RECT *lprc2);
UINT GetPrivateProfileIntA(LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault, LPCSTR lpFileName);
BOOL SetVolumeMountPointW(LPCWSTR lpszVolumeMountPoint, LPCWSTR lpszVolumeName);
float expf(float x);
HRESULT VarUI4FromDisp(unknown_t *pdispIn, LCID lcid, ULONG *pulOut);
VOID freeaddrinfo(unknown_t pAddrInfo);
HRESULT SHIsFileAvailableOffline(PCWSTR pwszPath, DWORD *pdwStatus);
UINT GetPrivateProfileIntW(LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault, LPCWSTR lpFileName);
ULONG ldap_modrdnA(LDAP *ExternalHandle, const PSTR DistinguishedName, const PSTR NewDistinguishedName);
BOOL SetVolumeLabelW(LPCWSTR lpRootPathName, LPCWSTR lpVolumeName);
BOOL SetSysColors(int cElements, INT *lpaElements, COLORREF *lpaRgbValues);
int DrawTextExW(HDC hdc, LPWSTR lpchText, int cchText, LPRECT lprc, UINT format, LPDRAWTEXTPARAMS lpdtp);
DWORD GetModuleFileNameExW(HANDLE hProcess, HMODULE hModule, LPWSTR lpFilename, DWORD nSize);
wint_t towctrans(wint_t wc, wctrans_t desc);
BOOL PowerSetRequest(HANDLE PowerRequest, POWER_REQUEST_TYPE RequestType);
ULONG ldap_parse_resultW(LDAP *Connection, LDAPMessage *ResultMessage, ULONG *ReturnCode, PWSTR *MatchedDNs, PWSTR *ErrorMessage, PZPWSTR *Referrals, PLDAPControlW **ServerControls, BOOLEAN Freeit);
HBRUSH CreateBrushIndirect();
void RtlFreeOemString(POEM_STRING OemString);
BOOL CredEnumerateA(LPCSTR Filter, DWORD Flags, DWORD *Count, PCREDENTIALA **Credential);
DWORD OemKeyScan(WORD wOemChar);
ULONG ldap_result2error(LDAP *ld, LDAPMessage *res, ULONG freeit);
DWORD ResumeThread(HANDLE hThread);
BOOL CertDeleteCTLFromStore(PCCTL_CONTEXT pCtlContext);
BOOL EndMenu();
ULONG ldap_rename_ext_sA(LDAP *ld, const PSTR dn, const PSTR NewRDN, const PSTR NewParent, INT DeleteOldRdn, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
DWORD GetModuleFileNameExA(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize);
HGDIOBJ GetCurrentObject(HDC hdc, unknown_t uObjectType);
BOOL GetDefaultUserProfileDirectoryA(LPSTR lpProfileDir, LPDWORD lpcchSize);
BOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted);
BOOL EnumProcesses(DWORD *lpidProcess, DWORD cb, LPDWORD lpcbNeeded);
BOOL RegisterPointerInputTarget(HWND hwnd, unknown_t pointerType);
DWORD GetDIBColorTable(HDC hdc, UINT uStartIndex, UINT cEntries, RGBQUAD *pColors);
BOOL CredEnumerateW(LPCWSTR Filter, DWORD Flags, DWORD *Count, PCREDENTIALW **Credential);
BOOL MaskBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, HBITMAP hbmMask, int xMask, int yMask, unknown_t dwRop);
ULONG ldap_rename_ext_sW(LDAP *ld, PWSTR dn, PWSTR NewRDN, PWSTR NewParent, INT DeleteOldRdn, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls);
BOOL GetDefaultUserProfileDirectoryW(LPWSTR lpProfileDir, LPDWORD lpcchSize);
BOOL IsValidAcl(PACL pAcl);
int CountClipboardFormats();
BOOL InflateRect(LPRECT lprc, int dx, int dy);
BOOL TrackMouseEvent(LPTRACKMOUSEEVENT lpEventTrack);
LSTATUS SHEnumValueA(HKEY hkey, DWORD dwIndex, PSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData);
BOOL GetPointerInfo(UINT32 pointerId, unknown_t *pointerInfo);
BOOL GetCursorInfo(PCURSORINFO pci);
BOOL InitializeProcThreadAttributeList(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, DWORD dwAttributeCount, DWORD dwFlags, PSIZE_T lpSize);
BOOL ChangeTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period);
BOOL CertSetCertificateContextProperty(PCCERT_CONTEXT pCertContext, DWORD dwPropId, DWORD dwFlags, const void *pvData);
int fegetenv(fenv_t *envp);
CONFIGRET CM_Set_Device_Interface_PropertyW(LPCWSTR pszDeviceInterface, unknown_t *PropertyKey, unknown_t PropertyType, PBYTE PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags);
LSTATUS SHEnumValueW(HKEY hkey, DWORD dwIndex, PWSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData);
BOOL GetKeyboardLayoutNameA(LPSTR pwszKLID);
PWCHAR * ldap_explode_dnW(PWSTR dn, ULONG notypes);
SECURITY_STATUS NCryptVerifyClaim(NCRYPT_KEY_HANDLE hSubjectKey, NCRYPT_KEY_HANDLE hAuthorityKey, DWORD dwClaimType, unknown_t *pParameterList, PBYTE pbClaimBlob, DWORD cbClaimBlob, unknown_t *pOutput, DWORD dwFlags);
double exp2(double x);
ULONG AddRef();
DPI_AWARENESS_CONTEXT SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT dpiContext);
PCHAR * ldap_explode_dnA(const PSTR dn, ULONG notypes);
float rintf(float x);
BOOL AddAccessAllowedAceEx(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid);
long GetDIBits(HDC hdc, HBITMAP hbmp, UINT uStartScan, UINT cScanLines, LPVOID lpvBits, LPBITMAPINFO lpbi, unknown_t uUsage);
BOOL CryptSetProviderExW(LPCWSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags);
BOOL TerminateProcess(HANDLE hProcess, UINT uExitCode);
long double rintl(long double x);
BOOL GetKeyboardLayoutNameW(LPWSTR pwszKLID);
HRESULT SHCreateShellItemArray(unknown_t pidlParent, unknown_t *psf, UINT cidl, unknown_t ppidl, unknown_t **ppsiItemArray);
float tgammaf(float x);
BOOL ConvertSidToStringSidW(PSID Sid, LPWSTR *StringSid);
int StrCmpNIA(PCSTR psz1, PCSTR psz2, int nChar);
LSTATUS SHRegEnumUSValueW(HUSKEY hUSkey, DWORD dwIndex, LPWSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData, unknown_t enumRegFlags);
void PathStripPathA(LPSTR pszPath);
ULONG ProcessTrace(PTRACEHANDLE HandleArray, ULONG HandleCount, LPFILETIME StartTime, LPFILETIME EndTime);
BOOL GetDevicePowerState(HANDLE hDevice, BOOL *pfOn);
BOOL GetFileInformationByHandleEx(HANDLE hFile, FILE_INFO_BY_HANDLE_CLASS FileInformationClass, LPVOID lpFileInformation, DWORD dwBufferSize);
long double tgammal(long double x);
ULONG ldap_add_extW(LDAP *ld, PWSTR dn, unknown_t **attrs, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, ULONG *MessageNumber);
CONFIGRET CM_Detect_Resource_Conflict(DEVINST dnDevInst, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, PBOOL pbConflictDetected, ULONG ulFlags);
BOOL HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength);
BOOL GetComputerNameExA(COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize);
LSTATUS SHRegEnumUSValueA(HUSKEY hUSkey, DWORD dwIndex, LPSTR pszValueName, LPDWORD pcchValueName, LPDWORD pdwType, void *pvData, LPDWORD pcbData, unknown_t enumRegFlags);
HRESULT GetErrorInfo(ULONG dwReserved, unknown_t **pperrinfo);
BOOL InsertMenuItemW(HMENU hmenu, UINT item, BOOL fByPosition, LPCMENUITEMINFOW lpmi);
BOOL CryptSetProviderExA(LPCSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags);
int fetestexcept(int excepts);
BOOL ConvertSidToStringSidA(PSID Sid, LPSTR *StringSid);
BOOL SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
BOOL InitNetworkAddressControl();
PCHAR ldap_next_attributeA(LDAP *ld, LDAPMessage *entry, BerElement *ptr);
BOOL GetComputerNameExW(COMPUTER_NAME_FORMAT NameType, LPWSTR lpBuffer, LPDWORD nSize);
int StrCmpNIW(PCWSTR psz1, PCWSTR psz2, int nChar);
void PathStripPathW(LPWSTR pszPath);
BOOL SystemParametersInfoW(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni);
INT GetTypeByNameW(LPWSTR lpServiceName, LPGUID lpServiceType);
ULONG ldap_add_extA(LDAP *ld, const PSTR dn, unknown_t **attrs, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
BOOL DebugActiveProcess(DWORD dwProcessId);
BOOL SymGetLinePrevW64(HANDLE hProcess, PIMAGEHLP_LINEW64 Line);
UINT SysStringLen(BSTR pbstr);
HRESULT IStream_Size(struct IStream *pstm, ULARGE_INTEGER *pui);
BOOL CertAddEncodedCTLToStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType, BYTE *pbCtlEncoded, DWORD cbCtlEncoded, DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext);
PWCHAR ldap_next_attributeW(LDAP *ld, LDAPMessage *entry, BerElement *ptr);
BOOL InsertMenuItemA(HMENU hmenu, UINT item, BOOL fByPosition, LPCMENUITEMINFOA lpmi);
HRESULT PathCchAddBackslashEx(PWSTR pszPath, size_t cchPath, PWSTR *ppszEnd, size_t *pcchRemaining);
ULONG ldap_simple_bind_sW(LDAP *ld, PWSTR dn, PWSTR passwd);
BOOL HeapWalk(HANDLE hHeap, LPPROCESS_HEAP_ENTRY lpEntry);
LRESULT DefFrameProcW(HWND hWnd, HWND hWndMDIClient, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL HeapUnlock(HANDLE hHeap);
BOOL SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni);
HRESULT CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
char * gets(char *s);
HRGN ExtCreateRegion(unknown_t *lpXform, DWORD nCount, unknown_t *lpRgnData);
SECURITY_STATUS NCryptStreamClose(NCRYPT_STREAM_HANDLE hStream);
LSTATUS SHCopyKeyA(HKEY hkeySrc, LPCSTR pszSrcSubKey, HKEY hkeyDest, DWORD fReserved);
LRESULT DefFrameProcA(HWND hWnd, HWND hWndMDIClient, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL EnumSystemGeoNames(GEOCLASS geoClass, GEO_ENUMNAMEPROC geoEnumProc, LPARAM data);
INT GetTypeByNameA(LPSTR lpServiceName, LPGUID lpServiceType);
UINT GlobalGetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize);
BOOL EnumSystemLocalesA(LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags);
ULONG ldap_search_abandon_page(PLDAP ExternalHandle, PLDAPSearch SearchBlock);
int ToUnicode(UINT wVirtKey, UINT wScanCode, BYTE *lpKeyState, LPWSTR pwszBuff, int cchBuff, UINT wFlags);
ULONG ldap_simple_bind_sA(LDAP *ld, PSTR dn, PSTR passwd);
BOOL TrackPopupMenuEx(HMENU hMenu, UINT uFlags, int x, int y, HWND hwnd, LPTPMPARAMS lptpm);
DWORD GetTapePosition(HANDLE hDevice, DWORD dwPositionType, LPDWORD lpdwPartition, LPDWORD lpdwOffsetLow, LPDWORD lpdwOffsetHigh);
HANDLE CreateRemoteThread(HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId);
CONFIGRET CM_Unregister_Notification(HCMNOTIFICATION NotifyContext);
LSTATUS SHCopyKeyW(HKEY hkeySrc, LPCWSTR pszSrcSubKey, HKEY hkeyDest, DWORD fReserved);
void OaEnablePerUserTLibRegistration();
int getc(FILE *stream);
HRESULT UrlCreateFromPathW(PCWSTR pszPath, PWSTR pszUrl, DWORD *pcchUrl, DWORD dwFlags);
size_t wcsftime(wchar_t *s, size_t maxsize, wchar_t *format, struct tm *timeptr);
BOOL CertEnumPhysicalStore(const void *pvSystemStore, DWORD dwFlags, void *pvArg, PFN_CERT_ENUM_PHYSICAL_STORE pfnEnum);
DWORD LoadModule(LPCSTR lpModuleName, LPVOID lpParameterBlock);
CONFIGRET CM_Enumerate_Enumerators_ExA(ULONG ulEnumIndex, PSTR Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
HRESULT VarBoolFromDec(DECIMAL *pdecIn, unknown_t *pboolOut);
UINT GlobalGetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize);
BOOL EnumSystemLocalesW(LOCALE_ENUMPROCW lpLocaleEnumProc, DWORD dwFlags);
HRESULT VarI4FromDec(DECIMAL *pdecIn, LONG *plOut);
HRESULT UrlCreateFromPathA(PCSTR pszPath, PSTR pszUrl, DWORD *pcchUrl, DWORD dwFlags);
HRESULT VarDateFromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, unknown_t *pdateOut);
DWORD GetObjectType(HGDIOBJ h);
BOOL CryptVerifyCertificateSignature(HCRYPTPROV_LEGACY hCryptProv, DWORD dwCertEncodingType, BYTE *pbEncoded, DWORD cbEncoded, PCERT_PUBLIC_KEY_INFO pPublicKey);
__attribute__((noreturn)) VOID FreeLibraryAndExitThread(HMODULE hLibModule, DWORD dwExitCode);
CONFIGRET CM_Get_Class_Property_Keys_Ex(LPCGUID ClassGUID, unknown_t *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags, HMACHINE hMachine);
LSTATUS SHRegSetPathA(HKEY hKey, LPCSTR pcszSubKey, LPCSTR pcszValue, LPCSTR pcszPath, DWORD dwFlags);
VOID ReleaseMutexWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, HANDLE mut);
BOOL RegisterTouchHitTestingWindow(HWND hwnd, ULONG value);
BOOL ReadConsoleA(HANDLE hConsoleInput, LPVOID lpBuffer, DWORD nNumberOfCharsToRead, LPDWORD lpNumberOfCharsRead, unknown_t pInputControl);
CONFIGRET CM_Enumerate_Enumerators_ExW(ULONG ulEnumIndex, PWSTR Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
NTSTATUS BCryptRemoveContextFunction(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction);
HRESULT SafeArrayDestroyData(unknown_t *psa);
HDESK CreateDesktopExA(LPCSTR lpszDesktop, LPCSTR lpszDevice, unknown_t *pDevmode, DWORD dwFlags, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa, ULONG ulHeapSize, PVOID pvoid);
BOOL CryptVerifyMessageSignature(PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, DWORD dwSignerIndex, BYTE *pbSignedBlob, DWORD cbSignedBlob, BYTE *pbDecoded, DWORD *pcbDecoded, PCCERT_CONTEXT *ppSignerCert);
HANDLE CreateIoCompletionPort(HANDLE FileHandle, HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads);
HRESULT CoMarshalInterface(LPSTREAM pStm, REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
BOOL CryptAcquireCertificatePrivateKey(PCCERT_CONTEXT pCert, DWORD dwFlags, void *pvParameters, HCRYPTPROV_OR_NCRYPT_KEY_HANDLE *phCryptProvOrNCryptKey, DWORD *pdwKeySpec, BOOL *pfCallerFreeProvOrNCryptKey);
LSTATUS SHDeleteValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue);
HDESK CreateDesktopExW(LPCWSTR lpszDesktop, LPCWSTR lpszDevice, unknown_t *pDevmode, DWORD dwFlags, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa, ULONG ulHeapSize, PVOID pvoid);
BOOL GetPointerFramePenInfoHistory(UINT32 pointerId, UINT32 *entriesCount, UINT32 *pointerCount, unknown_t *penInfo);
BOOL ChangeServiceConfigW(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName);
LSTATUS SHRegSetPathW(HKEY hKey, LPCWSTR pcszSubKey, LPCWSTR pcszValue, LPCWSTR pcszPath, DWORD dwFlags);
HRESULT VarCyFromDate(unknown_t dateIn, unknown_t *pcyOut);
HRESULT VarI1FromDate(unknown_t dateIn, CHAR *pcOut);
BOOL ReadConsoleW(HANDLE hConsoleInput, LPVOID lpBuffer, DWORD nNumberOfCharsToRead, LPDWORD lpNumberOfCharsRead, unknown_t pInputControl);
long ftell(FILE *stream);
BOOL GetJobW(HPRINTER hPrinter, DWORD JobId, int Level, LPBYTE pJob, int cbBuf, LPDWORD pcbNeeded);
BOOL EvaluateProximityToPolygon(UINT32 numVertices, POINT *controlPolygon, unknown_t *pHitTestingInput, unknown_t *pProximityEval);
PVOID RegisterBadMemoryNotification(PBAD_MEMORY_CALLBACK_ROUTINE Callback);
HRESULT CoDecrementMTAUsage(unknown_t Cookie);
BOOL SymGetSymNext(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol);
BOOL ObjectCloseAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose);
BOOL SetProcessAffinityUpdateMode(HANDLE hProcess, DWORD dwFlags);
LSTATUS SHDeleteValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue);
HDC CreateMetaFileW();
HRESULT SHEmptyRecycleBinA(HWND hwnd, LPCSTR pszRootPath, DWORD dwFlags);
BOOL GetLayeredWindowAttributes(HWND hwnd, COLORREF *pcrKey, BYTE *pbAlpha, DWORD *pdwFlags);
BOOL AddAuditAccessAceEx(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure);
BOOL ChangeServiceConfigA(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName);
BOOL FillRgn(HDC hdc, HRGN HRGN, HBRUSH hbr);
BOOL ObjectCloseAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose);
BOOL StartPagePrinter();
DWORD_PTR SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffinityMask);
size_t wcsrtombs(char *dst, wchar_t **src, size_t len, mbstate_t *ps);
PVOID ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders, PVOID Base, ULONG Rva, PIMAGE_SECTION_HEADER *LastRvaSection);
BOOL GetJobA(HPRINTER hPrinter, DWORD JobId, int Level, LPBYTE pJob, int cbBuf, LPDWORD pcbNeeded);
BOOL SetDlgItemTextA(HWND hDlg, int nIDDlgItem, LPCSTR lpString);
BOOL AddPrinterConnectionW();
HDC CreateMetaFileA();
PIDLIST_ABSOLUTE SHSimpleIDListFromPath(PCWSTR pszPath);
BOOL WriteConsoleOutputW(HANDLE hConsoleOutput, CHAR_INFO *lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, PSMALL_RECT lpWriteRegion);
DWORD GetTapeParameters(HANDLE hDevice, DWORD dwOperation, LPDWORD lpdwSize, LPVOID lpTapeInformation);
LPVOID CryptMemAlloc(ULONG cbSize);
BOOL GetScrollRange(HWND hWnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos);
DWORD VerLanguageNameW(DWORD wLang, LPWSTR szLang, DWORD cchLang);
UINT GetConsoleOutputCP();
BOOL ImageList_SetDragCursorImage(HIMAGELIST himlDrag, int iDrag, int dxHotspot, int dyHotspot);
BOOL GetCommModemStatus(HANDLE hFile, LPDWORD lpModemStat);
BOOL EnumDirTreeW(HANDLE hProcess, PCWSTR RootPath, PCWSTR InputPathName, PWSTR OutputPathBuffer, PENUMDIRTREE_CALLBACKW cb, PVOID data);
BOOL SymGetModuleInfoW64(HANDLE hProcess, DWORD64 qwAddr, PIMAGEHLP_MODULEW64 ModuleInfo);
HRESULT SHEmptyRecycleBinW(HWND hwnd, LPCWSTR pszRootPath, DWORD dwFlags);
BOOL WriteConsoleOutputA(HANDLE hConsoleOutput, CHAR_INFO *lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, PSMALL_RECT lpWriteRegion);
CONFIGRET CM_Register_Device_InterfaceA(DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCSTR pszReference, LPSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags);
BOOL SetForegroundWindow(HWND hWnd);
BOOL SymUnloadModule(HANDLE hProcess, DWORD BaseOfDll);
DWORD VerLanguageNameA(DWORD wLang, LPSTR szLang, DWORD cchLang);
BOOL AddPrinterConnectionA();
void objc_retainAutoreleasedReturnValue(void *instance);
DWORD K32GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize);
int GetMapMode(HDC hdc);
BOOL SetDlgItemTextW(HWND hDlg, int nIDDlgItem, LPCWSTR lpString);
HRESULT VarSub(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
HRESULT TranslateURL(LPCSTR pcszURL, unknown_t dwInFlags, LPSTR *ppszTranslatedURL);
BOOLEAN GetUserNameExW(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize);
HRESULT IStream_ReadStr(struct IStream *pstm, PWSTR *ppsz);
HRESULT VarUI2FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, USHORT *puiOut);
HRESULT VarI8FromBool(unknown_t boolIn, LONG64 *pi64Out);
wint_t fgetwc(FILE *stream);
HRESULT VarR4FromBool(unknown_t boolIn, FLOAT *pfltOut);
BOOL CryptDecodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType, BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo);
DWORD K32GetModuleBaseNameA(HANDLE hProcess, HMODULE hModule, LPSTR lpBaseName, DWORD nSize);
BOOLEAN GetUserNameExA(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize);
DWORD SetTapePosition(HANDLE hDevice, DWORD dwPositionMethod, DWORD dwPartition, DWORD dwOffsetLow, DWORD dwOffsetHigh, BOOL bImmediate);
VOID WaitForThreadpoolTimerCallbacks(PTP_TIMER pti, BOOL fCancelPendingCallbacks);
BOOL SymGetLineFromAddr64(HANDLE hProcess, DWORD64 qwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line64);
BOOL SymEnumerateSymbolsW64(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback, PVOID UserContext);
CONFIGRET CM_Register_Device_InterfaceW(DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCWSTR pszReference, LPWSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags);
int DlgDirListComboBoxA(HWND hDlg, LPSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype);
HIMAGELIST ImageList_LoadImageW(HINSTANCE hi, LPCWSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags);
BOOL IsDebuggerPresent();
HRESULT ImageList_ReadEx(DWORD dwFlags, struct IStream *pstm, REFIID riid, PVOID *ppv);
HMODULE LoadLibraryExA(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
int wcsncmp(wchar_t *s1, wchar_t *s2, size_t n);
BOOL ControlServiceExA(SC_HANDLE hService, DWORD dwControl, DWORD dwInfoLevel, PVOID pControlParams);
int vwprintf(wchar_t *format, va_list arg);
wchar_t * fgetws(wchar_t *s, int n, FILE *stream);
BOOL UrlIsW(PCWSTR pszUrl, unknown_t UrlIs);
CONFIGRET CM_Reenumerate_DevNode_Ex(DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
int DlgDirListComboBoxW(HWND hDlg, LPWSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype);
BOOL MoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName);
BOOL PolyPolyline(HDC hdc, POINT *lppt, DWORD *lpdwPolyPoints, DWORD cCount);
void IUnknown_AtomicRelease(void **ppunk);
HDC CreateDCA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput, unknown_t *lpInitData);
BOOL ControlServiceExW(SC_HANDLE hService, DWORD dwControl, DWORD dwInfoLevel, PVOID pControlParams);
HIMAGELIST ImageList_LoadImageA(HINSTANCE hi, LPCSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags);
BOOL UrlIsA(PCSTR pszUrl, unknown_t UrlIs);
HMODULE LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
HRESULT ConvertPerformanceCounterToAuxiliaryCounter(ULONGLONG ullPerformanceCounterValue, PULONGLONG lpAuxiliaryCounterValue, PULONGLONG lpConversionError);
HRESULT SHLoadNonloadedIconOverlayIdentifiers();
BOOL UpdateLayeredWindow(HWND hWnd, HDC hdcDst, POINT *pptDst, SIZE *psize, HDC hdcSrc, POINT *pptSrc, COLORREF crKey, unknown_t *pblend, DWORD dwFlags);
BOOL MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName);
HDC CreateDCW(LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, unknown_t *lpInitData);
CONFIGRET CM_Get_Child_Ex(unknown_t pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
BOOL ConfigurePortW(LPWSTR pName, HWND hWnd, LPWSTR pPortName);
BOOL CryptRegisterDefaultOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, DWORD dwIndex, LPCWSTR pwszDll);
double acosh(double x);
UINT GetMenuState(HMENU hMenu, UINT uId, UINT uFlags);
long double acosl(long double x);
HRESULT Save(LPCOLESTR pszFileName, BOOL fRemember);
float acosf(float x);
BOOL SetLocaleInfoA(LCID Locale, LCTYPE LCType, LPCSTR lpLCData);
BOOL SetWorldTransform(HDC hdc, unknown_t *lpXform);
ULONG ldap_bindA(LDAP *ld, PSTR dn, PCHAR cred, ULONG method);
HRESULT CoInitialize(LPVOID pvReserved);
BOOL ConfigurePortA(LPSTR pName, HWND hWnd, LPSTR pPortName);
LRESULT CallWindowProcA(FARPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL GetFileBandwidthReservation(HANDLE hFile, LPDWORD lpPeriodMilliseconds, LPDWORD lpBytesPerPeriod, LPBOOL pDiscardable, LPDWORD lpTransferSize, LPDWORD lpNumOutstandingRequests);
void setbuf(FILE *stream, char *buf);
BOOL GetScrollBarInfo(HWND hwnd, LONG idObject, PSCROLLBARINFO psbi);
PTP_WORK CreateThreadpoolWork(PTP_WORK_CALLBACK pfnwk, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
BOOL ReadPrinter(HPRINTER hPrinter, LPVOID pBuf, int cbBuf, LPDWORD pNoBytesRead);
int CompareStringEx(LPCWSTR lpLocaleName, DWORD dwCmpFlags, LPCWCH lpString1, int cchCount1, LPCWCH lpString2, int cchCount2, LPNLSVERSIONINFO lpVersionInformation, LPVOID lpReserved, LPARAM lParam);
HRESULT RegisterTypeLibForUser(unknown_t *ptlib, unknown_t *szFullPath, unknown_t *szHelpDir);
BOOL EndPagePrinter();
HRESULT VarDateFromDec(DECIMAL *pdecIn, unknown_t *pdateOut);
BOOL GetNumberOfConsoleInputEvents(HANDLE hConsoleInput, LPDWORD lpNumberOfEvents);
HRESULT TaskDialog(HWND hwndOwner, HINSTANCE hInstance, PCWSTR pszWindowTitle, PCWSTR pszMainInstruction, PCWSTR pszContent, TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons, PCWSTR pszIcon, int *pnButton);
ULONG ldap_search_ext_s(LDAP *ld, PSTR base, ULONG scope, PSTR filter, PZPSTR attrs, ULONG attrsonly, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, struct l_timeval *timeout, ULONG SizeLimit, PLDAPMessage *res);
DWORD GdiSetBatchLimit();
LSTATUS SHRegQueryUSValueA(HUSKEY hUSKey, LPCSTR pszValue, DWORD *pdwType, void *pvData, DWORD *pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, DWORD dwDefaultDataSize);
LSTATUS RegEnumKeyW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, DWORD cchName);
BOOL ChangeServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo);
HWND GetShellWindow();
LRESULT CallWindowProcW(FARPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL Polygon(HDC hdc, POINT *lpPoints, int nCount);
ULONG ldap_bindW(LDAP *ld, PWSTR dn, PWCHAR cred, ULONG method);
COLORREF ImageList_SetBkColor(HIMAGELIST himl, COLORREF clrBk);
BOOL SetLocaleInfoW(LCID Locale, LCTYPE LCType, LPCWSTR lpLCData);
HRESULT StgGetIFillLockBytesOnILockBytes(unknown_t *pilb, unknown_t **ppflb);
BOOL GetPerformanceInfo(PPERFORMANCE_INFORMATION pPerformanceInformation, DWORD cb);
BOOL DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions);
int GetSystemMetrics(int nIndex);
LSTATUS RegEnumKeyA(HKEY hKey, DWORD dwIndex, LPSTR lpName, DWORD cchName);
BOOL ChangeServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo);
int MessageBoxExA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType, WORD wLanguageId);
BOOL GetNumberOfEventLogRecords(HANDLE hEventLog, PDWORD NumberOfRecords);
ULONG ldap_create_sort_control(PLDAP ExternalHandle, PLDAPSortKeyA *SortKeys, UCHAR IsCritical, PLDAPControlA *Control);
HRESULT SHSetTemporaryPropertyForItem(unknown_t *psi, unknown_t propkey, unknown_t propvar);
HRESULT VarDecFromCy(unknown_t cyIn, DECIMAL *pdecOut);
BOOL IsWindowEnabled(HWND hWnd);
BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);
LSTATUS SHRegQueryUSValueW(HUSKEY hUSKey, LPCWSTR pszValue, DWORD *pdwType, void *pvData, DWORD *pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, DWORD dwDefaultDataSize);
BOOL InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpContext);
int MessageBoxExW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType, WORD wLanguageId);
void DrawInsert(HWND handParent, HWND hLB, int nItem);
BOOL AbortPath();
NTSTATUS NtQueryInformationProcess(HANDLE ProcessHandle, unknown_t ProcessInformationClass, PVOID ProcessInformation, ULONG ProcessInformationLength, PULONG ReturnLength);
HRESULT GetCurrentProcessExplicitAppUserModelID(PWSTR *AppID);
BOOL EnumResourceTypesW(HMODULE hModule, ENUMRESTYPEPROCW lpEnumFunc, LONG_PTR lParam);
BOOL GetPrinterDriverA(HPRINTER hPrinter, LPSTR pEnvironment, unknown_t Level, LPBYTE pDriverInfo, int cbBuf, LPDWORD pcbNeeded);
BOOL ShowHideMenuCtl(HWND hWnd, UINT_PTR uFlags, LPINT lpInfo);
BOOL DrawEdge(HDC hdc, LPRECT qrc, UINT edge, UINT grfFlags);
CONFIGRET CM_Is_Dock_Station_Present_Ex(PBOOL pbPresent, HMACHINE hMachine);
ULONG CoAddRefServerProcess();
HRESULT CoUnmarshalInterface(LPSTREAM pStm, REFIID riid, LPVOID *ppv);
ULONG ldap_extended_operationA(LDAP *ld, const PSTR Oid, struct berval *Data, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID pSid);
int vswscanf(wchar_t *s, wchar_t *format, va_list arg);
HRESULT CoGetSystemSecurityPermissions(unknown_t comSDType, PSECURITY_DESCRIPTOR *ppSD);
INT WSAQuerySocketSecurity(SOCKET Socket, unknown_t *SecurityQueryTemplate, ULONG SecurityQueryTemplateLen, unknown_t *SecurityQueryInfo, ULONG *SecurityQueryInfoLen, LPWSAOVERLAPPED Overlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine);
SECURITY_STATUS NCryptGetProtectionDescriptorInfo(NCRYPT_DESCRIPTOR_HANDLE hDescriptor, unknown_t *pMemPara, DWORD dwInfoType, void **ppvInfo);
BOOL EnumServicesStatusA(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, unknown_t lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle);
long SetArcDirection(HDC hdc, unknown_t ArcDirection);
ULONG ldap_extended_operationW(LDAP *ld, PWSTR Oid, struct berval *Data, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, ULONG *MessageNumber);
DWORD GetCompressedFileSizeW(LPCWSTR lpFileName, LPDWORD lpFileSizeHigh);
BOOL IsValidDpiAwarenessContext(DPI_AWARENESS_CONTEXT value);
HRESULT GetActiveObject(unknown_t rclsid, void *pvReserved, IUnknown **ppunk);
BOOL EnumResourceTypesA(HMODULE hModule, ENUMRESTYPEPROCA lpEnumFunc, LONG_PTR lParam);
BOOL GetPrinterDriverW(HPRINTER hPrinter, LPWSTR pEnvironment, unknown_t Level, LPBYTE pDriverInfo, int cbBuf, LPDWORD pcbNeeded);
HWINSTA CreateWindowStationW(LPCWSTR lpwinsta, DWORD dwFlags, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa);
CONFIGRET CM_Setup_DevNode(DEVINST dnDevInst, ULONG ulFlags);
BOOL EnumServicesStatusW(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, unknown_t lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle);
BOOL CertVerifyRevocation(DWORD dwEncodingType, DWORD dwRevType, DWORD cContext, PVOID *rgpvContext, DWORD dwFlags, PCERT_REVOCATION_PARA pRevPara, PCERT_REVOCATION_STATUS pRevStatus);
COORD GetLargestConsoleWindowSize(HANDLE hConsoleOutput);
BOOL ArcTo(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect, int nXRadial1, int nYRadial1, int nXRadial2, int nYRadial2);
ULONG ldap_extended_operation(LDAP *ld, const PSTR Oid, struct berval *Data, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
DWORD GetCompressedFileSizeA(LPCSTR lpFileName, LPDWORD lpFileSizeHigh);
VOID GetLocalTime(LPSYSTEMTIME lpSystemTime);
HRESULT CreateTypeLib2(unknown_t syskind, LPCOLESTR szFile, unknown_t **ppctlib);
LSTATUS SHRegCloseUSKey(HUSKEY hUSKey);
BOOL TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
BOOL CryptDecryptAndVerifyMessageSignature(PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara, PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, DWORD dwSignerIndex, BYTE *pbEncryptedBlob, DWORD cbEncryptedBlob, BYTE *pbDecrypted, DWORD *pcbDecrypted, PCCERT_CONTEXT *ppXchgCert, PCCERT_CONTEXT *ppSignerCert);
ULONG ldap_modify_ext_sA(LDAP *ld, const PSTR dn, unknown_t **mods, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
HWINSTA CreateWindowStationA(LPCSTR lpwinsta, DWORD dwFlags, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa);
ULONG ldap_escape_filter_elementW(PCHAR sourceFilterElement, ULONG sourceLength, PWCHAR destFilterElement, ULONG destLength);
BOOL GetXStateFeaturesMask(PCONTEXT Context, PDWORD64 FeatureMask);
HRESULT DecodeRemotePointer(HANDLE ProcessHandle, PVOID Ptr, PVOID *DecodedPtr);
INT WSARemoveServiceClass(LPGUID lpServiceClassId);
BOOL WSAResetEvent(WSAEVENT hEvent);
HANDLE FindExecutableImageEx(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath, PFIND_EXE_FILE_CALLBACK Callback, PVOID CallerData);
int WSARecvFrom(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct sockaddr *lpFrom, LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
VOID ldap_memfree(PCHAR Block);
BOOL ShutdownBlockReasonDestroy(HWND hWnd);
HRESULT CLSIDFromProgID(LPCOLESTR lpszProgID, LPCLSID lpclsid);
int GetCurrencyFormatEx(LPCWSTR lpLocaleName, DWORD dwFlags, LPCWSTR lpValue, unknown_t *lpFormat, LPWSTR lpCurrencyStr, int cchCurrency);
double tgamma(double x);
DPI_AWARENESS GetAwarenessFromDpiAwarenessContext(DPI_AWARENESS_CONTEXT value);
ULONG ldap_escape_filter_elementA(PCHAR sourceFilterElement, ULONG sourceLength, PCHAR destFilterElement, ULONG destLength);
NTSTATUS BCryptQueryContextFunctionProperty(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, LPCWSTR pszProperty, ULONG *pcbValue, PUCHAR *ppbValue);
BOOL RoundRect(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect, int nWidth, int nHeight);
BOOL CertCompareCertificateName(DWORD dwCertEncodingType, PCERT_NAME_BLOB pCertName1, PCERT_NAME_BLOB pCertName2);
ULONG ldap_modify_ext_sW(LDAP *ld, PWSTR dn, unknown_t **mods, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls);
BOOL GetDeviceGammaRamp(HDC hDC, LPVOID lpRamp);
HRESULT CoGetApartmentType(APTTYPE *pAptType, APTTYPEQUALIFIER *pAptQualifier);
BOOL GetThreadGroupAffinity(HANDLE hThread, unknown_t GroupAffinity);
BOOL DeletePrinterConnectionA();
HRESULT VarCyFromBool(unknown_t boolIn, unknown_t *pcyOut);
HRESULT GetApplicationRestartSettings(HANDLE hProcess, PWSTR pwzCommandline, PDWORD pcchSize, PDWORD pdwFlags);
CONFIGRET CM_Get_Device_ID_List_ExA(PCSTR pszFilter, PZZSTR Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine);
HRESULT BindMoniker(unknown_t pmk, DWORD grfOpt, REFIID iidResult, LPVOID *ppvResult);
BOOL CertStrToNameA(DWORD dwCertEncodingType, LPCSTR pszX500, DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded, LPCSTR *ppszError);
HRESULT SHGetDesktopFolder();
HRESULT FreePropVariantArray(ULONG cVariants, unknown_t *rgvars);
PTP_CLEANUP_GROUP CreateThreadpoolCleanupGroup();
BOOL DeletePrinterConnectionW();
BOOL CertStrToNameW(DWORD dwCertEncodingType, LPCWSTR pszX500, DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded, LPCWSTR *ppszError);
PVOID SymFunctionTableAccess64AccessRoutines(HANDLE hProcess, DWORD64 AddrBase, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine);
DWORD GetActiveProcessorCount(WORD GroupNumber);
BOOL CryptBinaryToStringA(BYTE *pbBinary, DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString);
const char * getprogname();
BOOL DestroyWindow(HWND hWnd);
LPSTR CharPrevExA(WORD CodePage, LPCSTR lpStart, LPCSTR lpCurrentChar, DWORD dwFlags);
CONFIGRET CM_Get_Device_ID_List_ExW(PCWSTR pszFilter, PZZWSTR Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine);
HRESULT CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc, unknown_t *asAuthSvc, void *pReserved1, DWORD dwAuthnLevel, DWORD dwImpLevel, void *pAuthList, DWORD dwCapabilities, void *pReserved3);
BOOL Wow64GetThreadContext(HANDLE hThread, PWOW64_CONTEXT lpContext);
BOOL PathIsDirectoryW(LPCWSTR pszPath);
HRESULT VarDecFromI8(LONG64 i64In, DECIMAL *pdecOut);
BOOL SymEnumSourceLines(HANDLE hProcess, ULONG64 Base, PCSTR Obj, PCSTR File, DWORD Line, DWORD Flags, PSYM_ENUMLINES_CALLBACK EnumLinesCallback, PVOID UserContext);
VOID SetLastErrorEx(DWORD dwErrCode, DWORD dwType);
HRESULT VarDecFromI4(LONG lIn, DECIMAL *pdecOut);
HPEN CreatePenIndirect();
UINT GetSystemFirmwareTable(DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize);
long lrintl(long double x);
__attribute__((noreturn)) VOID FatalExit(int ExitCode);
CONFIGRET CM_Is_Dock_Station_Present(PBOOL pbPresent);
HRESULT VarDecFromI1(CHAR cIn, DECIMAL *pdecOut);
BOOL IsNLSDefinedString(NLS_FUNCTION Function, DWORD dwFlags, LPNLSVERSIONINFO lpVersionInformation, LPCWSTR lpString, INT cchStr);
BOOL BackupSeek(HANDLE hFile, DWORD dwLowBytesToSeek, DWORD dwHighBytesToSeek, LPDWORD lpdwLowByteSeeked, LPDWORD lpdwHighByteSeeked, LPVOID *lpContext);
INT SysReAllocString(BSTR *pbstr, unknown_t *psz);
BOOL QueryMemoryResourceNotification(HANDLE ResourceNotificationHandle, PBOOL ResourceState);
HRESULT VarDecFromI2(SHORT uiIn, DECIMAL *pdecOut);
BOOL CryptBinaryToStringW(BYTE *pbBinary, DWORD cbBinary, DWORD dwFlags, LPWSTR pszString, DWORD *pcchString);
HPRINTER FindFirstPrinterChangeNotification(HPRINTER hPrinter, unknown_t fdwFlags, int fdwOptions, unknown_t pPrinterNotifyOptions);
BOOL PathIsDirectoryA(LPCSTR pszPath);
void PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath);
BOOL CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, WCHAR *pwszDllList, DWORD *pcchDllList);
BOOL UrlIsOpaqueA(PCSTR pszURL);
long lrintf(float x);
DWORD WinHttpGetProxyForUrlEx(HINTERNET hResolver, PCWSTR pcwszUrl, unknown_t *pAutoProxyOptions, DWORD_PTR pContext);
BOOL PathUnExpandEnvStringsA(LPCSTR pszPath, LPSTR pszBuf, UINT cchBuf);
BOOL LockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh);
BOOL SymQueryInlineTrace(HANDLE hProcess, DWORD64 StartAddress, DWORD StartContext, DWORD64 StartRetAddress, DWORD64 CurAddress, LPDWORD CurContext, LPDWORD CurFrameIndex);
LSTATUS RegNotifyChangeKeyValue(HKEY hKey, BOOL bWatchSubtree, DWORD dwNotifyFilter, HANDLE hEvent, BOOL fAsynchronous);
BOOL PathUnExpandEnvStringsW(LPCWSTR pszPath, LPWSTR pszBuf, UINT cchBuf);
void PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath);
BOOL UrlIsOpaqueW(PCWSTR pszURL);
HRESULT CreateAntiMoniker(unknown_t *ppmk);
PUMS_CONTEXT GetCurrentUmsThread();
int WSAEventSelect(SOCKET s, WSAEVENT hEventObject, long lNetworkEvents);
int strncasecmp(const char *s1, const char *s2, size_t n);
LRESULT SendMessageTimeoutA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags, UINT uTimeout, PDWORD_PTR lpdwResult);
int ToAsciiEx(UINT uVirtKey, UINT uScanCode, BYTE *lpKeyState, LPWORD lpChar, UINT uFlags, HKL dwhkl);
HKEY SHRegDuplicateHKey(HKEY hkey);
BOOL SetEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpValue);
BOOL DefineDosDeviceA(DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath);
HRESULT RoGetAgileReference(AgileReferenceOptions options, REFIID riid, IUnknown *pUnk, unknown_t **ppAgileReference);
BOOL CreateProcessAsUserA(HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
BOOL FileEncryptionStatusW(LPCWSTR lpFileName, LPDWORD lpStatus);
BOOL GetProcessMitigationPolicy(HANDLE hProcess, PROCESS_MITIGATION_POLICY MitigationPolicy, PVOID lpBuffer, SIZE_T dwLength);
int WPUCompleteOverlappedRequest(SOCKET s, LPWSAOVERLAPPED lpOverlapped, DWORD dwError, DWORD cbTransferred, LPINT lpErrno);
HRESULT VarR8FromDisp(unknown_t *pdispIn, LCID lcid, DOUBLE *pdblOut);
VOID WaitForThreadpoolWorkCallbacks(PTP_WORK pwk, BOOL fCancelPendingCallbacks);
BOOL SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue);
void RtlInitString(PSTRING DestinationString, PCSZ SourceString);
BOOL FileEncryptionStatusA(LPCSTR lpFileName, LPDWORD lpStatus);
HRESULT CoGetClassObject(unknown_t rclsid, DWORD dwClsContext, LPVOID pvReserved, REFIID riid, LPVOID *ppv);
LRESULT SendMessageTimeoutW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags, UINT uTimeout, PDWORD_PTR lpdwResult);
BOOL DefineDosDeviceW(DWORD dwFlags, LPCWSTR lpDeviceName, LPCWSTR lpTargetPath);
BOOL WaitNamedPipeA(LPCSTR lpNamedPipeName, DWORD nTimeOut);
BOOL IsNormalizedString(NORM_FORM NormForm, LPCWSTR lpString, int cwLength);
BOOL DebugActiveProcessStop(DWORD dwProcessId);
BOOL CreateProcessAsUserW(HANDLE hToken, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
BOOL SetWindowContextHelpId(HWND ARG_0, DWORD ARG_1);
BOOL UnregisterPointerInputTargetEx(HWND hwnd, unknown_t pointerType);
BOOL CreateHardLinkW(LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
SIZE_T GlobalCompact(DWORD dwMinFree);
BOOL CertUnregisterSystemStore(const void *pvSystemStore, DWORD dwFlags);
BOOL TerminateJobObject(HANDLE hJob, UINT uExitCode);
VOID FreeMemoryJobObject(VOID *Buffer);
BOOL GetNamedPipeClientSessionId(HANDLE Pipe, PULONG ClientSessionId);
BOOL AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength);
PCCERT_CONTEXT CertGetIssuerCertificateFromStore(HCERTSTORE hCertStore, PCCERT_CONTEXT pSubjectContext, PCCERT_CONTEXT pPrevIssuerContext, DWORD *pdwFlags);
CONFIGRET CM_Find_Range(PDWORDLONG pullStart, DWORDLONG ullStart, ULONG ulLength, DWORDLONG ullAlignment, DWORDLONG ullEnd, unknown_t rlh, ULONG ulFlags);
HWND CreateDialogIndirectParamA(HINSTANCE hInstance, LPCDLGTEMPLATEA lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
int MapWindowPoints(HWND hWndFrom, HWND hWndTo, LPPOINT lpPoints, UINT cPoints);
HRESULT VarI4FromBool(unknown_t boolIn, LONG *plOut);
int OffsetClipRgn(HDC hdc, int nXOffset, int nYOffset);
HRESULT CoCreateInstanceEx(unknown_t Clsid, IUnknown *punkOuter, DWORD dwClsCtx, unknown_t *pServerInfo, DWORD dwCount, unknown_t *pResults);
BOOL GetCIMSSM(unknown_t *inputMessageSource);
BOOL WaitNamedPipeW(LPCWSTR lpNamedPipeName, DWORD nTimeOut);
HDC GetDCEx(HWND hWnd, HRGN hrgnClip, DWORD flags);
BOOL SetWindowTextW(HWND hWnd, LPCWSTR lpString);
BERVAL * ber_bvdup(BERVAL *pBerVal);
BOOL GetSystemFileCacheSize(PSIZE_T lpMinimumFileCacheSize, PSIZE_T lpMaximumFileCacheSize, PDWORD lpFlags);
ULONG ldap_modify_sW(LDAP *ld, PWSTR dn, unknown_t **mods);
BOOL CreateHardLinkA(LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
VOID GetSystemTimePreciseAsFileTime(LPFILETIME lpSystemTimeAsFileTime);
BOOL GetClassInfoExA(HINSTANCE hInstance, LPCSTR lpszClass, LPWNDCLASSEXA lpwcx);
HANDLE CreateFileTransactedA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile, HANDLE hTransaction, PUSHORT pusMiniVersion, PVOID lpExtendedParameter);
CONFIGRET CM_Get_Class_PropertyW(LPCGUID ClassGUID, unknown_t *PropertyKey, unknown_t *PropertyType, PBYTE PropertyBuffer, PULONG PropertyBufferSize, ULONG ulFlags);
CONFIGRET CM_Set_DevNode_Registry_PropertyA(DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags);
HWND CreateDialogIndirectParamW(HINSTANCE hInstance, LPCDLGTEMPLATEW lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
HWINSTA OpenWindowStationA(LPCSTR lpszWinSta, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
BOOL RemoveDllDirectory(DLL_DIRECTORY_COOKIE Cookie);
BOOL SetSystemTimeAdjustment(DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled);
LSTATUS RegDeleteKeyW(HKEY hKey, LPCWSTR lpSubKey);
NTSTATUS BCryptKeyDerivation(BCRYPT_KEY_HANDLE hKey, unknown_t *pParameterList, PUCHAR pbDerivedKey, ULONG cbDerivedKey, ULONG *pcbResult, ULONG dwFlags);
char * group_from_gid(gid_t gid, int nogroup);
BOOL GetClassInfoExW(HINSTANCE hInstance, LPCWSTR lpszClass, LPWNDCLASSEXW lpwcx);
HWINSTA OpenWindowStationW(LPCWSTR lpszWinSta, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
CONFIGRET CM_Set_DevNode_Registry_PropertyW(DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags);
BOOL StretchBlt(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, unknown_t dwRop);
BOOL SetWindowTextA(HWND hWnd, LPCSTR lpString);
ULONG ldap_modify_sA(LDAP *ld, PSTR dn, unknown_t **mods);
HANDLE CreateFileTransactedW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile, HANDLE hTransaction, PUSHORT pusMiniVersion, PVOID lpExtendedParameter);
SECURITY_STATUS NCryptGetProperty(NCRYPT_HANDLE hObject, LPCWSTR pszProperty, PBYTE pbOutput, DWORD cbOutput, DWORD *pcbResult, DWORD dwFlags);
BOOL SetCommTimeouts(HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts);
BOOL SetGestureConfig(HWND hwnd, DWORD dwReserved, UINT cIDs, PGESTURECONFIG pGestureConfig, UINT cbSize);
int isprint(int c);
LSTATUS RegDeleteKeyA(HKEY hKey, LPCSTR lpSubKey);
int fscanf(FILE *stream, const char *format, void *va_args);
CONFIGRET CM_Unregister_Device_InterfaceW(LPCWSTR pszDeviceInterface, ULONG ulFlags);
ULONG TraceQueryInformation(TRACEHANDLE SessionHandle, TRACE_INFO_CLASS InformationClass, PVOID TraceInformation, ULONG InformationLength, PULONG ReturnLength);
BOOL SoundSentry();
BOOL PathSearchAndQualifyW(LPCWSTR pszPath, LPWSTR pszBuf, UINT cchBuf);
BOOL WinHttpDetectAutoProxyConfigUrl(DWORD dwAutoDetectFlags, LPWSTR *ppwstrAutoConfigUrl);
HBRUSH CreateHatchBrush(int fnStyle, COLORREF clrref);
HANDLE GetProcessHeap();
int FlatSB_GetScrollPos(HWND ARG_0, int code);
BOOL WriteConsoleOutputAttribute(HANDLE hConsoleOutput, WORD *lpAttribute, DWORD nLength, COORD dwWriteCoord, LPDWORD lpNumberOfAttrsWritten);
PUCHAR GetSidSubAuthorityCount(PSID pSid);
NTSTATUS BCryptVerifySignature(BCRYPT_KEY_HANDLE hKey, VOID *pPaddingInfo, PUCHAR pbHash, ULONG cbHash, PUCHAR pbSignature, ULONG cbSignature, ULONG dwFlags);
NTSTATUS BCryptGetFipsAlgorithmMode(BOOLEAN *pfEnabled);
CONFIGRET CM_Unregister_Device_InterfaceA(LPCSTR pszDeviceInterface, ULONG ulFlags);
INT WSCInstallNameSpace32(LPWSTR lpszIdentifier, LPWSTR lpszPathName, DWORD dwNameSpace, DWORD dwVersion, LPGUID lpProviderId);
BOOL EvaluateProximityToRect(RECT *controlBoundingBox, unknown_t *pHitTestingInput, unknown_t *pProximityEval);
BOOL DeleteFileTransactedW(LPCWSTR lpFileName, HANDLE hTransaction);
DPI_HOSTING_BEHAVIOR GetThreadDpiHostingBehavior();
int WSCGetProviderPath(LPGUID lpProviderId, WCHAR *lpszProviderDllPath, LPINT lpProviderDllPathLen, LPINT lpErrno);
BOOL CloseDesktop(HDESK hDesktop);
DWORD GetDeviceDriverFileNameW(LPVOID ImageBase, LPWSTR lpFilename, DWORD nSize);
BOOL SetPixelV(HDC hdc, int X, int Y, COLORREF crColor);
BOOL PathSearchAndQualifyA(LPCSTR pszPath, LPSTR pszBuf, UINT cchBuf);
BOOL DeleteColorSpace();
UINT DragQueryFileW(HDROP hDrop, UINT iFile, LPWSTR lpszFile, UINT cch);
UINT GetACP();
BOOL RequestWakeupLatency(LATENCY_TIME latency);
UINT DragQueryFileA(HDROP hDrop, UINT iFile, LPSTR lpszFile, UINT cch);
BOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID *pOwner, LPBOOL lpbOwnerDefaulted);
DWORD GetDeviceDriverFileNameA(LPVOID ImageBase, LPSTR lpFilename, DWORD nSize);
BOOL DeleteFileTransactedA(LPCSTR lpFileName, HANDLE hTransaction);
BOOL GetComboBoxInfo(HWND hwndCombo, unknown_t pcbi);
HANDLE FindExecutableImage(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath);
BOOL PolyDraw(HDC hdc, POINT *lppt, unknown_t *lpbTypes, int cCount);
int Escape(HDC hdc, unknown_t escapeCode, int cbSize, LPSTR pszInData, LPVOID pOutData);
VOID DeleteProcThreadAttributeList(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList);
BOOL IsRectEmpty(RECT *lprc);
int FrameRect(HDC hDC, RECT *lprc, HBRUSH hbr);
BOOL SHCreateProcessAsUserW(PSHCREATEPROCESSINFOW pscpi);
CONFIGRET CM_Intersect_Range_List(unknown_t rlhOld1, unknown_t rlhOld2, unknown_t rlhNew, ULONG ulFlags);
UINT GetRawInputDeviceInfoW(HANDLE hDevice, UINT uiCommand, LPVOID pData, PUINT pcbSize);
long GetMetaRgn(HDC hdc, HRGN HRGN);
BOOL DeleteEnhMetaFile();
SECURITY_STATUS NCryptSecretAgreement(NCRYPT_KEY_HANDLE hPrivKey, NCRYPT_KEY_HANDLE hPubKey, NCRYPT_SECRET_HANDLE *phAgreedSecret, DWORD dwFlags);
BOOL WriteConsoleInputW(HANDLE hConsoleInput, unknown_t *lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsWritten);
VOID RtlCaptureContext(PCONTEXT ContextRecord);
VOID TerminateProcessOnMemoryExhaustion(SIZE_T FailedAllocationSize);
HRESULT VariantChangeTypeEx(unknown_t *pvargDest, unknown_t *pvarSrc, LCID lcid, USHORT wFlags, VARTYPE vt);
BOOL SymFromNameW(HANDLE hProcess, PCWSTR Name, PSYMBOL_INFOW Symbol);
BOOL WriteConsoleInputA(HANDLE hConsoleInput, unknown_t *lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsWritten);
SECURITY_STATUS NCryptCreateProtectionDescriptor(LPCWSTR pwszDescriptorString, DWORD dwFlags, NCRYPT_DESCRIPTOR_HANDLE *phDescriptor);
DWORD ReadEncryptedFileRaw(PFE_EXPORT_FUNC pfExportCallback, PVOID pvCallbackContext, PVOID pvContext);
BOOL SetRectEmpty(LPRECT lprc);
wchar_t * wcsncat(wchar_t *s1, wchar_t *s2, size_t n);
HRESULT SHGetLocalizedName(PCWSTR pszPath, PWSTR pszResModule, UINT cch, int *pidsRes);
int SHFileOperationA(LPSHFILEOPSTRUCTA lpFileOp);
int fseek(FILE *stream, long offset, int whence);
DWORD WinHttpWebSocketSend(HINTERNET hWebSocket, WINHTTP_WEB_SOCKET_BUFFER_TYPE eBufferType, PVOID pvBuffer, DWORD dwBufferLength);
VOID Sleep(DWORD dwMilliseconds);
UINT GetRawInputDeviceInfoA(HANDLE hDevice, UINT uiCommand, LPVOID pData, PUINT pcbSize);
BOOL QueueUserWorkItem(LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags);
BOOL ImageList_BeginDrag(HIMAGELIST himlTrack, int iTrack, int dxHotspot, int dyHotspot);
BOOL CryptCloseAsyncHandle(HCRYPTASYNC hAsync);
char * strdup(const char *src);
BOOL StrokePath();
int printf(const char *format);
BOOL GetPointerTouchInfo(UINT32 pointerId, unknown_t *touchInfo);
int GetThreadPriority(HANDLE hThread);
HRESULT AssocCreate(unknown_t clsid, REFIID riid, void **ppv);
int SHFileOperationW(LPSHFILEOPSTRUCTW lpFileOp);
BOOL CryptGetUserKey(HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey);
BOOL GetGestureConfig(HWND hwnd, DWORD dwReserved, DWORD dwFlags, PUINT pcIDs, PGESTURECONFIG pGestureConfig, UINT cbSize);
BOOL HideCaret(HWND hWnd);
int strcoll(const char *s1, const char *s2);
BOOL RectVisible(HDC hdc, RECT *lprc);
SECURITY_STATUS NCryptEnumAlgorithms(NCRYPT_PROV_HANDLE hProvider, DWORD dwAlgOperations, DWORD *pdwAlgCount, unknown_t **ppAlgList, DWORD dwFlags);
HRESULT MonikerRelativePathTo(unknown_t pmkSrc, unknown_t pmkDest, unknown_t *ppmkRelPath, BOOL dwReserved);
BOOL GetNumaHighestNodeNumber(PULONG HighestNodeNumber);
HCRYPTOIDFUNCSET CryptInitOIDFunctionSet(LPCSTR pszFuncName, DWORD dwFlags);
BOOL CertSetCRLContextProperty(PCCRL_CONTEXT pCrlContext, DWORD dwPropId, DWORD dwFlags, const void *pvData);
BOOL Decompress(DECOMPRESSOR_HANDLE DecompressorHandle, LPCVOID CompressedData, SIZE_T CompressedDataSize, PVOID UncompressedBuffer, SIZE_T UncompressedBufferSize, PSIZE_T UncompressedDataSize);
BOOL WinHttpSendRequest(HINTERNET hRequest, LPCWSTR lpszHeaders, DWORD dwHeadersLength, LPVOID lpOptional, DWORD dwOptionalLength, DWORD dwTotalLength, DWORD_PTR dwContext);
BOOL IsValidLocaleName(LPCWSTR lpLocaleName);
BOOL FreeResource(HGLOBAL hResData);
CONFIGRET CM_Open_Device_Interface_KeyW(LPCWSTR pszDeviceInterface, REGSAM samDesired, unknown_t Disposition, PHKEY phkDeviceInterface, ULONG ulFlags);
ULONG ber_scanf(BerElement *pBerElement, PSTR fmt, unknown_t ...);
VOID QuerySecurityAccessMask(SECURITY_INFORMATION SecurityInformation, LPDWORD DesiredAccess);
DWORD CertOIDToAlgId(LPCSTR pszObjId);
BOOL EnumDisplaySettingsA(LPCSTR lpszDeviceName, DWORD iModeNum, unknown_t *lpDevMode);
void * realloc(void *ptr, size_t size);
CONFIGRET CM_Get_Depth(PULONG pulDepth, DEVINST dnDevInst, ULONG ulFlags);
VOID ber_bvecfree(PBERVAL *pBerVal);
HRESULT CoRevokeClassObject(DWORD dwRegister);
int ToUnicodeEx(UINT wVirtKey, UINT wScanCode, BYTE *lpKeyState, LPWSTR pwszBuff, int cchBuff, UINT wFlags, HKL dwhkl);
BOOL UnregisterSuspendResumeNotification(HPOWERNOTIFY Handle);
BOOL CheckRemoteDebuggerPresent(HANDLE hProcess, PBOOL pbDebuggerPresent);
BOOL SymPrev(HANDLE hProcess, PSYMBOL_INFO si);
BOOL CertAddCTLLinkToStore(HCERTSTORE hCertStore, PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition, PCCTL_CONTEXT *ppStoreContext);
BOOL UnrealizeObject();
DWORD WaitForMultipleObjects(DWORD nCount, HANDLE *lpHandles, BOOL bWaitAll, DWORD dwMilliseconds);
BOOL ReadConsoleOutputW(HANDLE hConsoleOutput, PCHAR_INFO lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, PSMALL_RECT lpReadRegion);
LDAPMessage * ldap_next_entry(LDAP *ld, LDAPMessage *entry);
CONFIGRET CM_Open_Device_Interface_KeyA(LPCSTR pszDeviceInterface, REGSAM samDesired, unknown_t Disposition, PHKEY phkDeviceInterface, ULONG ulFlags);
UINT GetWindowsDirectoryA(LPSTR lpBuffer, UINT uSize);
SECURITY_STATUS NCryptCloseProtectionDescriptor(NCRYPT_DESCRIPTOR_HANDLE hDescriptor);
BOOL EnumDisplaySettingsW(LPCWSTR lpszDeviceName, DWORD iModeNum, unknown_t *lpDevMode);
HRESULT ParseURLW(LPCWSTR pcszURL, unknown_t *ppu);
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
BOOL SetBrushOrgEx(HDC hdc, int nXOrg, int nYOrg, LPPOINT lppt);
UINT GetWindowsDirectoryW(LPWSTR lpBuffer, UINT uSize);
HRESULT VariantClear(unknown_t *pvarg);
char * ctime(time_t *timer);
SECURITY_STATUS NCryptStreamOpenToProtect(NCRYPT_DESCRIPTOR_HANDLE hDescriptor, DWORD dwFlags, HWND hWnd, unknown_t *pStreamInfo, NCRYPT_STREAM_HANDLE *phStream);
BOOL ReadConsoleOutputA(HANDLE hConsoleOutput, PCHAR_INFO lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, PSMALL_RECT lpReadRegion);
BOOL EqualDomainSid(PSID pSid1, PSID pSid2, BOOL *pfEqual);
BOOL GetMessageW(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax);
HRESULT ParseURLA(LPCSTR pcszURL, unknown_t *ppu);
HRESULT VarFormatCurrency(LPVARIANT pvarIn, int iNumDig, int iIncLead, int iUseParens, int iGroup, ULONG dwFlags, BSTR *pbstrOut);
LSTATUS SHRegGetValueFromHKCUHKLM(PCWSTR pwszKey, PCWSTR pwszValue, unknown_t srrfFlags, DWORD *pdwType, void *pvData, DWORD *pcbData);
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);
LPSTR PathSkipRootA(LPCSTR pszPath);
BOOLEAN GetComputerObjectNameA(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize);
BOOL SymPrevW(HANDLE hProcess, PSYMBOL_INFOW siw);
LSTATUS RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult);
DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR pSecurityDescriptor);
BOOL GetMessageA(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax);
BOOL BackupEventLogA(HANDLE hEventLog, LPCSTR lpBackupFileName);
int __toupper(int c);
HRESULT CoEnableCallCancellation(LPVOID pReserved);
BOOL IsWellKnownSid(PSID pSid, WELL_KNOWN_SID_TYPE WellKnownSidType);
HRESULT CoIncrementMTAUsage(unknown_t *pCookie);
BOOL EnumDesktopWindows(HDESK hDesktop, unknown_t lpfn, LPARAM lParam);
LPWSTR PathSkipRootW(LPCWSTR pszPath);
BOOLEAN GetComputerObjectNameW(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize);
HRESULT CoTestCancel();
HANDLE GetCurrentProcess();
void RtlFreeAnsiString(PANSI_STRING AnsiString);
UINT GetWriteWatch(DWORD dwFlags, PVOID lpBaseAddress, SIZE_T dwRegionSize, PVOID *lpAddresses, ULONG_PTR *lpdwCount, LPDWORD lpdwGranularity);
ldiv_t ldiv(long numer, long denom);
BOOL BackupEventLogW(HANDLE hEventLog, LPCWSTR lpBackupFileName);
BOOL GetPointerDeviceCursors(HANDLE device, UINT32 *cursorCount, unknown_t *deviceCursors);
BOOL GetProcessDEPPolicy(HANDLE hProcess, LPDWORD lpFlags, PBOOL lpPermanent);
int WSAUnhookBlockingHook();
LSTATUS RegOpenKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult);
HRESULT CoDisconnectObject(LPUNKNOWN pUnk, DWORD dwReserved);
BOOL FlatSB_GetScrollProp(HWND ARG_0, int propIndex, LPINT ARG_2);
UINT_PTR SetCoalescableTimer(HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, unknown_t lpTimerFunc, ULONG uToleranceDelay);
BOOL CryptEnumOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, DWORD dwFlags, void *pvArg, PFN_CRYPT_ENUM_OID_FUNC pfnEnumOIDFunc);
BOOL SymNext(HANDLE hProcess, PSYMBOL_INFO si);
BOOL SetConsoleOutputCP(UINT wCodePageID);
int iswblank(wint_t wc);
HRESULT VarUI2FromDisp(unknown_t *pdispIn, LCID lcid, USHORT *puiOut);
BOOL SetBitmapDimensionEx(HBITMAP hBitmap, int nWidth, int nHeight, LPSIZE lpSize);
BOOL WinHttpQueryOption(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, LPDWORD lpdwBufferLength);
float acoshf(float x);
BOOL UpdateColors();
BOOL GetNamedPipeInfo(HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutBufferSize, LPDWORD lpInBufferSize, LPDWORD lpMaxInstances);
BOOL CertEnumSubjectInSortedCTL(PCCTL_CONTEXT pCtlContext, void **ppvNextSubject, PCRYPT_DER_BLOB pSubjectIdentifier, PCRYPT_DER_BLOB pEncodedAttributes);
HRESULT VarI1FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, CHAR *pcOut);
BOOL CryptMsgSignCTL(DWORD dwMsgEncodingType, BYTE *pbCtlContent, DWORD cbCtlContent, PCMSG_SIGNED_ENCODE_INFO pSignInfo, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded);
BOOL EnumChildWindows(HWND hWndParent, unknown_t lpEnumFunc, LPARAM lParam);
HRESULT CoRegisterMallocSpy(unknown_t pMallocSpy);
BOOL EnumPrinterDataA(HPRINTER hPrinter, int dwIndex, LPSTR pValueName, int cbValueName, int *pcbValueName, unknown_t *pType, LPBYTE pData, int cbData, int *pcbData);
BOOL ShowScrollBar(HWND hWnd, int wBar, BOOL bShow);
CONFIGRET CM_Get_Next_Log_Conf(unknown_t plcLogConf, unknown_t lcLogConf, ULONG ulFlags);
long double acoshl(long double x);
BOOL CryptVerifyMessageHash(PCRYPT_HASH_MESSAGE_PARA pHashPara, BYTE *pbHashedBlob, DWORD cbHashedBlob, BYTE *pbToBeHashed, DWORD *pcbToBeHashed, BYTE *pbComputedHash, DWORD *pcbComputedHash);
BOOL GetVolumePathNameW(LPCWSTR lpszFileName, LPWSTR lpszVolumePathName, DWORD cchBufferLength);
BOOL GetSystemTimeAdjustment(PDWORD lpTimeAdjustment, PDWORD lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled);
HRESULT IStream_ReadPidl(struct IStream *pstm, unknown_t *ppidlOut);
VOID StartThreadpoolIo(PTP_IO pio);
BOOL GetCurrentActCtx(HANDLE *lphActCtx);
BOOL GetVolumePathNameA(LPCSTR lpszFileName, LPSTR lpszVolumePathName, DWORD cchBufferLength);
NTSTATUS BCryptEnumContexts(ULONG dwTable, ULONG *pcbBuffer, PCRYPT_CONTEXTS *ppBuffer);
HRESULT VarBstrFromDisp(unknown_t *pdispIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
BOOL EnumPrinterDataW(HPRINTER hPrinter, int dwIndex, LPWSTR pValueName, int cbValueName, int *pcbValueName, unknown_t *pType, LPBYTE pData, int cbData, int *pcbData);
BOOL SetCachedSigningLevel(PHANDLE SourceFiles, ULONG SourceFileCount, ULONG Flags, HANDLE TargetFile);
BOOL LogicalToPhysicalPointForPerMonitorDPI(HWND hWnd, LPPOINT lpPoint);
DWORD WinHttpGetProxyResultEx(HINTERNET hResolver, unknown_t *pProxyResultEx);
CONFIGRET CM_Get_First_Log_Conf_Ex(unknown_t plcLogConf, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
BOOL OffsetWindowOrgEx(HDC hdc, int nXOffset, int nYOffset, LPPOINT lpPoint);
DWORD DisableThreadProfiling(HANDLE PerformanceDataHandle);
HRESULT VarI4FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, LONG *plOut);
BOOL K32QueryWorkingSetEx(HANDLE hProcess, PVOID pv, DWORD cb);
BOOL SelectClipPath(HDC hdc, unknown_t iMode);
BOOL CertResyncCertificateChainEngine(HCERTCHAINENGINE hChainEngine);
BOOL AreAllAccessesGranted(DWORD GrantedAccess, DWORD DesiredAccess);
ULONG GetTraceEnableFlags(TRACEHANDLE TraceHandle);
wchar_t * wmemcpy(wchar_t *s1, wchar_t *s2, size_t n);
int feholdexcept(fenv_t *envp);
SHORT GetKeyState(int nVirtKey);
LRESULT DefRawInputProc(PRAWINPUT *paRawInput, INT nInput, UINT cbSizeHeader);
PCCTL_CONTEXT CertCreateCTLContext(DWORD dwMsgAndCertEncodingType, BYTE *pbCtlEncoded, DWORD cbCtlEncoded);
LDAP * ldap_initW(PWSTR HostName, ULONG PortNumber);
BOOL CryptQueryObject(DWORD dwObjectType, const void *pvObject, DWORD dwExpectedContentTypeFlags, DWORD dwExpectedFormatTypeFlags, DWORD dwFlags, DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, DWORD *pdwFormatType, HCERTSTORE *phCertStore, HCRYPTMSG *phMsg, const void **ppvContext);
BOOL CryptProtectData(unknown_t *pDataIn, LPCWSTR szDataDescr, unknown_t *pOptionalEntropy, PVOID pvReserved, unknown_t *pPromptStruct, DWORD dwFlags, unknown_t *pDataOut);
DWORD GetLastError();
ULONG ldap_encode_sort_controlW(PLDAP ExternalHandle, PLDAPSortKeyW *SortKeys, PLDAPControlW Control, BOOLEAN Criticality);
HCURSOR CreateCursor(HINSTANCE hInst, int xHotSpot, int yHotSpot, int nWidth, int nHeight, VOID *pvANDPlane, VOID *pvXORPlane);
BOOL AccessCheckByTypeResultListAndAuditAlarmByHandleA(LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose);
VOID CloseThreadpoolWait(PTP_WAIT pwa);
LDAP * ldap_initA(const PSTR HostName, ULONG PortNumber);
ULONG ldap_encode_sort_controlA(PLDAP ExternalHandle, PLDAPSortKeyA *SortKeys, PLDAPControlA Control, BOOLEAN Criticality);
BOOL FlatSB_GetScrollInfo(HWND ARG_0, int code, LPSCROLLINFO ARG_2);
DWORD SleepEx(DWORD dwMilliseconds, BOOL bAlertable);
double ldexp(double value, int exp);
BOOL OemToCharBuffW(LPCSTR lpszSrc, LPWSTR lpszDst, DWORD cchDstLength);
HRGN CreatePolygonRgn(POINT *lppt, int cPoints, unknown_t fnPolyFillMode);
BOOL AccessCheckByTypeResultListAndAuditAlarmByHandleW(LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccessList, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose);
HRESULT CoInitializeEx(LPVOID pvReserved, DWORD dwCoInit);
int isxdigit(int c);
BOOL RegisterTouchWindow(HWND hwnd, ULONG ulFlags);
BOOL GetLastInputInfo(PLASTINPUTINFO plii);
BOOL OemToCharBuffA(LPCSTR lpszSrc, LPSTR lpszDst, DWORD cchDstLength);
int EnumPropsW(HWND hWnd, PROPENUMPROCW lpEnumFunc);
BOOL CertFreeCTLContext(PCCTL_CONTEXT pCtlContext);
int GetUserDefaultGeoName(LPWSTR geoName, int geoNameCount);
HRESULT SHLoadInProc();
SECURITY_STATUS NCryptFreeBuffer(PVOID pvInput);
BOOL ImageList_Replace(HIMAGELIST himl, int i, HBITMAP hbmImage, HBITMAP hbmMask);
BOOL K32GetWsChangesEx(HANDLE hProcess, PPSAPI_WS_WATCH_INFORMATION_EX lpWatchInfoEx, PDWORD cb);
BOOL FreeUserPhysicalPages(HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray);
wchar_t * wmemmove(wchar_t *s1, wchar_t *s2, size_t n);
int EnumPropsA(HWND hWnd, unknown_t lpEnumFunc);
UINT GetRawInputBuffer(PRAWINPUT pData, PUINT pcbSize, UINT cbSizeHeader);
LPAPI_VERSION ImagehlpApiVersion();
BOOL ClientToScreen(HWND hWnd, LPPOINT lpPoint);
CONFIGRET CM_Add_Res_Des_Ex(PRES_DES prdResDes, unknown_t lcLogConf, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine);
BOOL TrySubmitThreadpoolCallback(PTP_SIMPLE_CALLBACK pfns, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
int WSCGetProviderPath32(LPGUID lpProviderId, WCHAR *lpszProviderDllPath, LPINT lpProviderDllPathLen, LPINT lpErrno);
wint_t getwchar();
int EndDoc();
ULONG ControlTraceA(TRACEHANDLE TraceHandle, LPCSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties, ULONG ControlCode);
BOOL PathIsRelativeA(LPCSTR pszPath);
BOOL CheckColorsInGamut(HDC hDC, LPVOID lpRGBTriples, LPVOID lpBuffer, UINT nCount);
int swprintf(wchar_t *s, size_t n, wchar_t *format);
BOOL LocalUnlock(HLOCAL hMem);
char * strerror(int errnum);
BOOL CryptVerifyMessageSignatureWithKey(PCRYPT_KEY_VERIFY_MESSAGE_PARA pVerifyPara, PCERT_PUBLIC_KEY_INFO pPublicKeyInfo, BYTE *pbSignedBlob, DWORD cbSignedBlob, BYTE *pbDecoded, DWORD *pcbDecoded);
BOOL PathIsRelativeW(LPCWSTR pszPath);
BOOL SetFileTime(HANDLE hFile, FILETIME *lpCreationTime, FILETIME *lpLastAccessTime, FILETIME *lpLastWriteTime);
BOOL MapDialogRect(HWND hDlg, LPRECT lpRect);
BOOL CryptSignHashA(HCRYPTHASH hHash, DWORD dwKeySpec, LPCSTR szDescription, DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen);
BOOL Wow64RevertWow64FsRedirection(PVOID OlValue);
BOOL CryptMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, void *pvCtrlPara);
ULONG ControlTraceW(TRACEHANDLE TraceHandle, LPCWSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties, ULONG ControlCode);
HRESULT SHGetTemporaryPropertyForItem(unknown_t *psi, unknown_t propkey, unknown_t *ppropvar);
HGLOBAL GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags);
BOOL SymSrvGetFileIndexInfoW(PCWSTR File, PSYMSRV_INDEX_INFOW Info, DWORD Flags);
TRACEHANDLE OpenTraceW(PEVENT_TRACE_LOGFILEW Logfile);
VOID ReleaseSRWLockShared(PSRWLOCK SRWLock);
BOOL GetUserObjectSecurity(HANDLE hObj, PSECURITY_INFORMATION pSIRequested, PSECURITY_DESCRIPTOR pSID, DWORD nLength, LPDWORD lpnLengthNeeded);
HDEVNOTIFY RegisterDeviceNotificationW(HANDLE hRecipient, LPVOID NotificationFilter, DWORD Flags);
size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps);
void DragFinish(HDROP hDrop);
BOOL SHGetDiskFreeSpaceA(LPCSTR pszVolume, ULARGE_INTEGER *pqwFreeCaller, ULARGE_INTEGER *pqwTot, ULARGE_INTEGER *pqwFree);
BOOL CryptSignHashW(HCRYPTHASH hHash, DWORD dwKeySpec, LPCWSTR szDescription, DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen);
BOOL ImageList_SetImageCount(HIMAGELIST himl, UINT uNewCount);
TRACEHANDLE OpenTraceA(PEVENT_TRACE_LOGFILEA Logfile);
int fesetenv(fenv_t *arg);
long wcstoul(wchar_t *nptr, wchar_t **endptr, int base);
HDEVNOTIFY RegisterDeviceNotificationA(HANDLE hRecipient, LPVOID NotificationFilter, DWORD Flags);
HRESULT LoadTypeLibEx(LPCOLESTR szFile, unknown_t regkind, unknown_t **pptlib);
BOOL SetConsoleScreenBufferInfoEx(HANDLE hConsoleOutput, PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx);
DWORD GetThreadId(HANDLE Thread);
BOOL WinHttpTimeToSystemTime(LPCWSTR pwszTime, SYSTEMTIME *pst);
double asin(double x);
ULONG ldap_result(LDAP *ld, ULONG msgid, ULONG all, PLDAP_TIMEVAL timeout, PLDAPMessage *res);
BOOL EnumerateLoadedModulesEx(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, PVOID UserContext);
HRESULT VarR4FromUI8(ULONG64 ui64In, FLOAT *pfltOut);
HRESULT VarR4FromUI4(ULONG ulIn, FLOAT *pfltOut);
HRESULT VarUI8FromDisp(unknown_t *pdispIn, LCID lcid, ULONG64 *pi64Out);
CONFIGRET CM_Detect_Resource_Conflict_Ex(DEVINST dnDevInst, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, PBOOL pbConflictDetected, ULONG ulFlags, HMACHINE hMachine);
BOOL CertSetCertificateContextPropertiesFromCTLEntry(PCCERT_CONTEXT pCertContext, PCTL_ENTRY pCtlEntry, DWORD dwFlags);
NTSTATUS BCryptGenRandom(BCRYPT_ALG_HANDLE hAlgorithm, PUCHAR pbBuffer, ULONG cbBuffer, ULONG dwFlags);
ULONGLONG VerSetConditionMask(ULONGLONG ConditionMask, ULONG TypeMask, UCHAR Condition);
BOOL GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask, PDWORD_PTR lpSystemAffinityMask);
HRESULT VarR4FromUI1(BYTE bIn, FLOAT *pfltOut);
BOOL SetPhysicalCursorPos(int X, int Y);
double cbrt(double x);
HRESULT VarR4FromUI2(USHORT uiIn, FLOAT *pfltOut);
int sleep(int s);
BOOL SetPortW(LPWSTR pName, LPWSTR pPortName, DWORD dwLevel, unknown_t pPortInfo);
HRESULT CLSIDFromProgIDEx(LPCOLESTR lpszProgID, LPCLSID lpclsid);
HRESULT VarFormat(LPVARIANT pvarIn, LPOLESTR pstrFormat, int iFirstDay, int iFirstWeek, ULONG dwFlags, BSTR *pbstrOut);
HRESULT CreateGenericComposite(unknown_t pmkFirst, unknown_t pmkRest, unknown_t *ppmkComposite);
UINT RealizePalette();
PVOID EncodeSystemPointer(PVOID Ptr);
HANDLE CreatePrivateNamespaceA(LPSECURITY_ATTRIBUTES lpPrivateNamespaceAttributes, LPVOID lpBoundaryDescriptor, LPCSTR lpAliasPrefix);
DWORD WinHttpWebSocketShutdown(HINTERNET hWebSocket, USHORT usStatus, PVOID pvReason, DWORD dwReasonLength);
SOCKET WPUModifyIFSHandle(DWORD dwCatalogEntryId, SOCKET ProposedHandle, LPINT lpErrno);
BOOL ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount);
LSTATUS RegLoadKeyA(HKEY hKey, LPCSTR lpSubKey, LPCSTR lpFile);
HRESULT VarR8FromR4(FLOAT fltIn, DOUBLE *pdblOut);
int WSAGetLastError();
BOOL UnregisterGPNotification(HANDLE hEvent);
BOOL SetFileIoOverlappedRange(HANDLE FileHandle, PUCHAR OverlappedRangeStart, ULONG Length);
HANDLE CreatePrivateNamespaceW(LPSECURITY_ATTRIBUTES lpPrivateNamespaceAttributes, LPVOID lpBoundaryDescriptor, LPCWSTR lpAliasPrefix);
HRESULT VarI8FromDec(DECIMAL *pdecIn, LONG64 *pi64Out);
BOOL CryptSetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD dwFlags);
BOOL InitCommonControlsEx(unknown_t *picce);
DWORD PowerReadDCValue(HKEY RootPowerKey, GUID *SchemeGuid, GUID *SubGroupOfPowerSettingsGuid, GUID *PowerSettingGuid, PULONG Type, PUCHAR Buffer, LPDWORD BufferSize);
HRESULT VarCyMul(unknown_t cyLeft, unknown_t cyRight, unknown_t pcyResult);
DWORD WaitForInputIdle(HANDLE hProcess, DWORD dwMilliseconds);
HRGN CreateEllipticRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
BOOL SetPortA(LPSTR pName, LPSTR pPortName, DWORD dwLevel, unknown_t pPortInfo);
BOOL GlobalMemoryStatusEx(LPMEMORYSTATUSEX lpBuffer);
LSTATUS RegLoadKeyW(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpFile);
NTSTATUS NtRenameKey(HANDLE KeyHandle, PUNICODE_STRING NewName);
BOOL SymSearch(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, DWORD SymTag, PCSTR Mask, DWORD64 Address, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext, DWORD Options);
PTP_POOL CreateThreadpool(PVOID reserved);
BOOL UpdateWindow(HWND hWnd);
BOOL CertDeleteCertificateFromStore(PCCERT_CONTEXT pCertContext);
DWORD MsgWaitForMultipleObjectsEx(DWORD nCount, HANDLE *pHandles, DWORD dwMilliseconds, DWORD dwWakeMask, DWORD dwFlags);
BOOL CryptContextAddRef(HCRYPTPROV hProv, DWORD *pdwReserved, DWORD dwFlags);
int puts(const char *s);
int StartPage();
BOOL ObjectOpenAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose);
BOOL CryptFormatObject(DWORD dwCertEncodingType, DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, LPCSTR lpszStructType, BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, DWORD *pcbFormat);
int putc(int c, FILE *stream);
PWSTR StrStrNW(PCWSTR pszFirst, PCWSTR pszSrch, UINT cchMax);
BOOL CryptProtectMemory(LPVOID pDataIn, DWORD cbDataIn, DWORD dwFlags);
HRESULT UnRegisterTypeLib(REFGUID libID, WORD wVerMajor, WORD wVerMinor, LCID lcid, unknown_t syskind);
HRESULT VarIdiv(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
DWORD GetSymLoadError();
BOOL ObjectOpenAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose);
ULONG FlushTraceA(TRACEHANDLE TraceHandle, LPCSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
DWORD SetDIBColorTable(HDC hdc, UINT uStartIndex, UINT cEntries, RGBQUAD *pColors);
long lround(double x);
HCURSOR GetCursor();
LPTOP_LEVEL_EXCEPTION_FILTER SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter);
BOOL SetKeyboardState(LPBYTE lpKeyState);
BOOL GetDefaultPrinterW(LPWSTR pszBuffer, int *pcchBuffer);
INT ldap_parse_vlv_controlW(PLDAP ExternalHandle, PLDAPControlW *Control, PULONG TargetPos, PULONG ListCount, PBERVAL *Context, PINT ErrCode);
EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE esFlags);
void SHGetSettings(unknown_t lpsfs, unknown_t dwMask);
NTSTATUS NtNotifyChangeMultipleKeys(HANDLE MasterKeyHandle, ULONG Count, OBJECT_ATTRIBUTES *SubordinateObjects, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG CompletionFilter, BOOLEAN WatchTree, PVOID Buffer, ULONG BufferSize, BOOLEAN Asynchronous);
ULONG ldap_simple_bind(LDAP *ld, const PSTR dn, const PSTR passwd);
HRESULT StrRetToBufW(unknown_t *pstr, unknown_t pidl, LPWSTR pszBuf, UINT cchBuf);
BOOL SymFromName(HANDLE hProcess, PCSTR Name, PSYMBOL_INFO Symbol);
HBITMAP CreateCompatibleBitmap(HDC hdc, int nWidth, int nHeight);
HRESULT PathCchCanonicalize(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn);
ULONG FlushTraceW(TRACEHANDLE TraceHandle, LPCWSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
BOOL CoIsHandlerConnected(LPUNKNOWN pUnk);
double tan(double x);
int wnsprintfW(PWSTR pszDest, int cchDest, PCWSTR pszFmt, unknown_t ...);
HRESULT StrRetToBufA(unknown_t *pstr, unknown_t pidl, LPSTR pszBuf, UINT cchBuf);
INT ldap_parse_vlv_controlA(PLDAP ExternalHandle, PLDAPControlA *Control, PULONG TargetPos, PULONG ListCount, PBERVAL *Context, PINT ErrCode);
PCCERT_CONTEXT CertGetSubjectCertificateFromStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, PCERT_INFO pCertId);
LSTATUS SHDeleteEmptyKeyA(HKEY hkey, LPCSTR pszSubKey);
BOOL GetDefaultPrinterA(LPSTR pszBuffer, int *pcchBuffer);
BOOL FileTimeToLocalFileTime(FILETIME *lpFileTime, LPFILETIME lpLocalFileTime);
HRESULT VarI2FromUI1(BYTE bIn, SHORT *psOut);
HIMAGELIST ImageList_Read(struct IStream *pstm);
float coshf(float x);
BOOL ReplacePartitionUnit(PWSTR TargetPartition, PWSTR SparePartition, ULONG Flags);
HRESULT VarI2FromUI2(USHORT uiIn, SHORT *psOut);
int wnsprintfA(PSTR pszDest, int cchDest, PCSTR pszFmt, unknown_t ...);
DWORD GetProcessId(HANDLE Process);
int WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
HRESULT VarI2FromUI4(ULONG ulIn, SHORT *psOut);
BOOL ModifyMenuA(HMENU hMnu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem);
int StrCmpNICA(LPCSTR pszStr1, LPCSTR pszStr2, int nChar);
HRESULT VarI8FromCy(unknown_t cyIn, LONG64 *pi64Out);
HRESULT VarI2FromUI8(ULONG64 ui64In, SHORT *psOut);
DWORD K32GetModuleFileNameExW(HANDLE hProcess, HMODULE hModule, LPWSTR lpFilename, DWORD nSize);
DEVICE_SCALE_FACTOR GetScaleFactorForDevice(DISPLAY_DEVICE_TYPE deviceType);
BOOL GetVolumeNameForVolumeMountPointA(LPCSTR lpszVolumeMountPoint, LPSTR lpszVolumeName, DWORD cchBufferLength);
long double coshl(long double x);
LSTATUS SHDeleteEmptyKeyW(HKEY hkey, LPCWSTR pszSubKey);
SHORT GetAsyncKeyState(int vKey);
LSTATUS RegDisablePredefinedCacheEx();
BOOL DeleteService(SC_HANDLE hService);
BOOL ModifyMenuW(HMENU hMnu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem);
BOOL GetVolumeNameForVolumeMountPointW(LPCWSTR lpszVolumeMountPoint, LPWSTR lpszVolumeName, DWORD cchBufferLength);
ULONG ldap_modify_extA(LDAP *ld, const PSTR dn, unknown_t **mods, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
int isalpha(int c);
BOOL PowerClearRequest(HANDLE PowerRequest, POWER_REQUEST_TYPE RequestType);
HWND GetClipboardViewer();
HANDLE FindFirstVolumeMountPointW(LPCWSTR lpszRootPathName, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength);
BOOL SymEnumSymbolsEx(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext, DWORD Options);
CONFIGRET CM_Enumerate_Classes(ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags);
int StrCmpNICW(LPCWSTR pszStr1, LPCWSTR pszStr2, int nChar);
LPVOID CreateFiberEx(SIZE_T dwStackCommitSize, SIZE_T dwStackReserveSize, DWORD dwFlags, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter);
BOOL IsWindow(HWND hWnd);
BOOL WSAIsBlocking();
CONFIGRET CM_Free_Resource_Conflict_Handle(unknown_t clConflictList);
BOOL AddSIDToBoundaryDescriptor(HANDLE *BoundaryDescriptor, PSID RequiredSid);
DWORD K32GetModuleFileNameExA(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize);
BOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor);
VOID CloseThreadpoolCleanupGroupMembers(PTP_CLEANUP_GROUP ptpcg, BOOL fCancelPendingCallbacks, PVOID pvCleanupContext);
LDAP * ldap_open(PSTR HostName, ULONG PortNumber);
ULONG ldap_modify_extW(LDAP *ld, PWSTR dn, unknown_t **mods, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, ULONG *MessageNumber);
BOOL CryptHashCertificate(HCRYPTPROV_LEGACY hCryptProv, ALG_ID Algid, DWORD dwFlags, BYTE *pbEncoded, DWORD cbEncoded, BYTE *pbComputedHash, DWORD *pcbComputedHash);
HANDLE FindFirstVolumeMountPointA(LPCSTR lpszRootPathName, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength);
BOOL EnumPageFilesW(PENUM_PAGE_FILE_CALLBACKW pCallBackRoutine, LPVOID pContext);
HICON ImageList_GetIcon(HIMAGELIST himl, int i, UINT flags);
char * getenv(const char *name);
BOOL SetThreadpoolWaitEx(PTP_WAIT pwa, HANDLE h, PFILETIME pftTimeout, PVOID Reserved);
LANGID GetSystemDefaultUILanguage();
BOOL AddConditionalAce(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, UCHAR AceType, DWORD AccessMask, PSID pSid, PWCHAR ConditionStr, DWORD *ReturnLength);
BOOL PathIsNetworkPathA(LPCSTR pszPath);
BOOL UnregisterPointerInputTarget(HWND hwnd, unknown_t pointerType);
HMENU GetSystemMenu(HWND hWnd, BOOL bRevert);
HRESULT SafeArrayAllocData(unknown_t *psa);
wchar_t * wcsncpy(wchar_t *s1, wchar_t *s2, size_t n);
BOOL WinHttpSetOption(HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength);
BOOL EnumPageFilesA(PENUM_PAGE_FILE_CALLBACKA pCallBackRoutine, LPVOID pContext);
HRESULT VariantCopyInd(VARIANT *pvarDest, unknown_t *pvargSrc);
COLORREF GetPixel(HDC hdc, int nXPos, int nYPos);
BOOL GetThreadPreferredUILanguages(DWORD dwFlags, PULONG pulNumLanguages, PZZWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer);
long GetTextFaceA(HDC hdc, int nCount, LPSTR lpFaceName);
BOOL SearchTreeForFile(PCSTR RootPath, PCSTR InputPathName, PSTR OutputPathBuffer);
BOOL CryptSignAndEncodeCertificate(BCRYPT_KEY_HANDLE hBCryptKey, DWORD dwKeySpec, DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm, const void *pvHashAuxInfo, BYTE *pbEncoded, DWORD *pcbEncoded);
VOID FreeLibraryWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, HMODULE mod);
HRESULT VarBoolFromR8(DOUBLE dblIn, unknown_t *pboolOut);
ULONG ldap_unbind(LDAP *ld);
long GetTextFaceW(HDC hdc, int nCount, LPWSTR lpFaceName);
INT getnameinfo(SOCKADDR *pSockaddr, socklen_t SockaddrLength, PCHAR pNodeBuffer, DWORD NodeBufferSize, PCHAR pServiceBuffer, DWORD ServiceBufferSize, INT Flags);
BOOL DeletePortA(LPSTR pName, HWND hWnd, LPSTR pPortName);
BOOL GetProcessorSystemCycleTime(USHORT Group, PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION Buffer, PDWORD ReturnedLength);
UINT_PTR SHAppBarMessage(DWORD dwMessage, PAPPBARDATA pData);
BOOL EnumPrintProcessorDatatypesA(LPSTR pName, LPSTR pPrintProcessorName, int Level, LPSTR pDatatypes, int cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned);
BOOL PathIsNetworkPathW(LPCWSTR pszPath);
BOOL SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT value);
HRESULT VarBoolFromR4(FLOAT fltIn, unknown_t *pboolOut);
BOOL CheckTokenMembershipEx(HANDLE TokenHandle, PSID SidToCheck, DWORD Flags, PBOOL IsMember);
PIMAGE_NT_HEADERS ImageNtHeader(PVOID Base);
BOOL CryptDecodeMessage(DWORD dwMsgTypeFlags, PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara, PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, DWORD dwSignerIndex, BYTE *pbEncodedBlob, DWORD cbEncodedBlob, DWORD dwPrevInnerContentType, DWORD *pdwMsgType, DWORD *pdwInnerContentType, BYTE *pbDecoded, DWORD *pcbDecoded, PCCERT_CONTEXT *ppXchgCert, PCCERT_CONTEXT *ppSignerCert);
bool isgreater(double x, double y);
HRESULT GetCurFile();
long DeletePrinterKeyA(HPRINTER hPrinter, LPSTR pKeyName);
BOOL StackWalkEx(DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME_EX StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress, DWORD Flags);
BOOL DeletePortW(LPWSTR pName, HWND hWnd, LPWSTR pPortName);
BOOL SetCommConfig(HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize);
BOOL LockSetForegroundWindow(UINT uLockCode);
HRESULT StringFromIID(REFIID rclsid, LPOLESTR *lplpsz);
VOID QueryInterruptTimePrecise(PULONGLONG lpInterruptTimePrecise);
BOOL EnumPrintProcessorDatatypesW(LPWSTR pName, LPWSTR pPrintProcessorName, int Level, LPWSTR pDatatypes, int cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned);
BOOL CryptGetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszValueName, DWORD *pdwValueType, BYTE *pbValueData, DWORD *pcbValueData);
int ungetc(int c, FILE *stream);
int main(int argc, char **argv, char **envp);
BOOL GetNamedPipeClientComputerNameA(HANDLE Pipe, LPSTR ClientComputerName, ULONG ClientComputerNameLength);
BOOL BeginPath();
BOOL VirtualProtectFromApp(PVOID Address, SIZE_T Size, ULONG NewProtection, PULONG OldProtection);
long DeletePrinterKeyW(HPRINTER hPrinter, LPWSTR pKeyName);
ULONG ldap_addA(LDAP *ld, PSTR dn, unknown_t **attrs);
NTSTATUS BCryptQueryProviderRegistration(LPCWSTR pszProvider, ULONG dwMode, ULONG dwInterface, ULONG *pcbBuffer, PCRYPT_PROVIDER_REG *ppBuffer);
BOOL ChangeClipboardChain(HWND hWndRemove, HWND hWndNewNext);
HFONT CreateFontIndirectExA();
HANDLE CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName);
ULONG LdapMapErrorToWin32(ULONG LdapError);
BOOL PathMatchSpecW(LPCWSTR pszFile, LPCWSTR pszSpec);
double round(double x);
PSTR StrStrIA(PCSTR pszFirst, PCSTR pszSrch);
BOOL GetNamedPipeClientComputerNameW(HANDLE Pipe, LPWSTR ClientComputerName, ULONG ClientComputerNameLength);
BOOL EnumThreadWindows(DWORD dwThreadId, unknown_t lpfn, LPARAM lParam);
BOOL SymEnumProcesses(PSYM_ENUMPROCESSES_CALLBACK EnumProcessesCallback, PVOID UserContext);
CONFIGRET CM_Modify_Res_Des_Ex(PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine);
DWORD GetTimestampForLoadedLibrary(HMODULE Module);
NTSTATUS BCryptAddContextFunction(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, ULONG dwPosition);
ULONG ldap_addW(LDAP *ld, PWSTR dn, unknown_t **attrs);
BOOL SymGetSourceFileFromTokenW(HANDLE hProcess, PVOID Token, PCWSTR Params, PWSTR FilePath, DWORD Size);
HFONT CreateFontIndirectExW();
HRESULT VarUI4FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut);
DWORD CM_MapCrToWin32Err(CONFIGRET CmReturnCode, DWORD DefaultErr);
INT WSAAdvertiseProvider(GUID *puuidProviderId, const LPCNSPV2_ROUTINE pNSPv2Routine);
INT WSCUnInstallNameSpace32(LPGUID lpProviderId);
void CertRemoveStoreFromCollection(HCERTSTORE hCollectionStore, HCERTSTORE hSiblingStore);
float fmaxf(float x, float y);
HANDLE CreateFileMappingW(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName);
NTSTATUS BCryptEnumAlgorithms(ULONG dwAlgOperations, ULONG *pAlgCount, unknown_t **ppAlgList, ULONG dwFlags);
LONG SetWindowLongA(HWND hWnd, int nIndex, LONG dwNewLong);
long long wcstoull(wchar_t *nptr, wchar_t **endptr, int base);
BOOL StrTrimW(PWSTR psz, PCWSTR pszTrimChars);
PWSTR StrStrIW(PCWSTR pszFirst, PCWSTR pszSrch);
BOOL CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext, DWORD dwPropId, void *pvData, DWORD *pcbData);
HRESULT VarI2FromI4(LONG lIn, SHORT *psOut);
int ferror(FILE *stream);
BOOL SetUserObjectInformationA(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength);
CONFIGRET CM_Query_Arbitrator_Free_Size_Ex(PULONG pulSize, DEVINST dnDevInst, RESOURCEID ResourceID, ULONG ulFlags, HMACHINE hMachine);
HRGN CreatePolyPolygonRgn(POINT *lppt, INT *lpPolyCounts, int nCount, unknown_t fnPolyFillMode);
BOOL PathMatchSpecA(LPCSTR pszFile, LPCSTR pszSpec);
HRESULT VarI2FromI1(CHAR cIn, SHORT *psOut);
long double fmaxl(long double x, long double y);
BOOL GetOverlappedResultEx(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, DWORD dwMilliseconds, BOOL bAlertable);
BOOL TextOutW(HDC hdc, int nXStart, int nYStart, LPCWSTR lpString, int cbString);
HRESULT VarI2FromI8(LONG64 i64In, SHORT *psOut);
UINT GetErrorMode();
BOOL SetUserObjectInformationW(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength);
BOOL StrTrimA(PSTR psz, PCSTR pszTrimChars);
BOOL Arc(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect, int nXStartArc, int nYStartArc, int nXEndArc, int nYEndArc);
int ResolveLocaleName(LPCWSTR lpNameToResolve, LPWSTR lpLocaleName, int cchLocaleName);
HRESULT VarI1FromDec(DECIMAL *pdecIn, CHAR *pcOut);
DWORD WTSGetActiveConsoleSessionId();
BOOL DPtoLP(HDC hdc, LPPOINT lpPoints, int nCount);
LONG SetWindowLongW(HWND hWnd, int nIndex, LONG dwNewLong);
DWORD GetProcessImageFileNameW(HANDLE hProcess, LPWSTR lpImageFileName, DWORD nSize);
CONFIGRET CM_Get_Global_State_Ex(PULONG pulState, ULONG ulFlags, HMACHINE hMachine);
ULONG QueryTraceA(TRACEHANDLE TraceHandle, LPCSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
BOOL NotifyBootConfigStatus(BOOL BootAcceptable);
INT EnumProtocolsW(LPINT lpiProtocols, LPVOID lpProtocolBuffer, LPDWORD lpdwBufferLength);
VOID NotifyWinEvent(DWORD event, HWND hwnd, LONG idObject, LONG idChild);
BOOL IsValidSid(PSID pSid);
ULONG QueryTraceW(TRACEHANDLE TraceHandle, LPCWSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
BOOL IsMouseInPointerEnabled();
BOOL TextOutA(HDC hdc, int nXStart, int nYStart, LPCSTR lpString, int cbString);
BOOL CommConfigDialogA(LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC);
BOOL RegisterShellHookWindow(HWND hwnd);
LSTATUS RegDeleteKeyTransactedW(HKEY hKey, LPCWSTR lpSubKey, REGSAM samDesired, DWORD Reserved, HANDLE hTransaction, PVOID pExtendedParameter);
INT EnumProtocolsA(LPINT lpiProtocols, LPVOID lpProtocolBuffer, LPDWORD lpdwBufferLength);
PSLIST_ENTRY InterlockedPopEntrySList(PSLIST_HEADER ListHead);
BOOL GetFileMUIPath(DWORD dwFlags, PCWSTR pcwszFilePath, PWSTR pwszLanguage, PULONG pcchLanguage, PWSTR pwszFileMUIPath, PULONG pcchFileMUIPath, PULONGLONG pululEnumerator);
BOOL SymGetModuleInfoW(HANDLE hProcess, DWORD dwAddr, PIMAGEHLP_MODULEW ModuleInfo);
DWORD GetProcessImageFileNameA(HANDLE hProcess, LPSTR lpImageFileName, DWORD nSize);
BOOL RegisterPointerDeviceNotifications(HWND window, BOOL notifyRange);
int setjmp(jmp_buf env);
HANDLE FindDebugInfoFileExW(PCWSTR FileName, PCWSTR SymbolPath, PWSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACKW Callback, PVOID CallerData);
BOOL EnumDependentServicesW(SC_HANDLE hService, DWORD dwServiceState, unknown_t lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned);
PVOID EncodePointer(PVOID Ptr);
int toupper(int c);
char * bindtextdomain(char *domainname, char *dirname);
BOOL CommConfigDialogW(LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC);
BOOL GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait);
BOOL PtVisible(HDC hdc, int X, int Y);
LSTATUS RegDeleteKeyTransactedA(HKEY hKey, LPCSTR lpSubKey, REGSAM samDesired, DWORD Reserved, HANDLE hTransaction, PVOID pExtendedParameter);
BOOL EnumDependentServicesA(SC_HANDLE hService, DWORD dwServiceState, unknown_t lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned);
HRESULT VarR8FromI4(LONG lIn, DOUBLE *pdblOut);
BOOL GetUserProfileDirectoryA(HANDLE hToken, LPSTR lpProfileDir, LPDWORD lpcchSize);
BOOL BuildCommDCBAndTimeoutsW(LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts);
BOOL EnumDesktopsW(HWINSTA hwinsta, DESKTOPENUMPROCW lpEnumFunc, LPARAM lParam);
int fwprintf(FILE *stream, wchar_t *format);
HRESULT VarR8FromI1(CHAR cIn, DOUBLE *pdblOut);
LSTATUS RegCloseKey(HKEY hKey);
HINTERNET WinHttpWebSocketCompleteUpgrade(HINTERNET hRequest, DWORD_PTR pContext);
PCHAR ldap_first_attribute(LDAP *ld, LDAPMessage *entry, BerElement **ptr);
int fchmod(int fd, int mode);
ATOM RegisterClassExW(unknown_t *ARG_0);
HRESULT OleSavePictureFile(LPDISPATCH lpdispPicture, BSTR bstrFileName);
HRESULT VarR8FromI2(SHORT sIn, DOUBLE *pdblOut);
BOOL UnloadKeyboardLayout(HKL hkl);
BOOL BuildCommDCBAndTimeoutsA(LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts);
HRESULT VarR8FromI8(LONG64 i64In, DOUBLE *pdblOut);
BOOL SleepConditionVariableSRW(PCONDITION_VARIABLE ConditionVariable, PSRWLOCK SRWLock, DWORD dwMilliseconds, ULONG Flags);
HWND CreateDialogParamA(HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
BOOL AddJobA(HPRINTER hPrinter, int Level, unknown_t *pData, int cbBuf, LPDWORD pcbNeeded);
BOOL GetUserProfileDirectoryW(HANDLE hToken, LPWSTR lpProfileDir, LPDWORD lpcchSize);
HRESULT VarBoolFromI1(CHAR cIn, unknown_t *pboolOut);
BOOL EnumDesktopsA(HWINSTA hwinsta, DESKTOPENUMPROCA lpEnumFunc, LPARAM lParam);
VOID WinHttpFreeProxyResultEx(unknown_t *pProxyResultEx);
BOOL ReadProcessMemory(HANDLE hProcess, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T *lpNumberOfBytesRead);
BOOL EnumJobsA(HPRINTER hPrinter, int FirstJob, int NoJobs, int Level, LPBYTE pJob, int cbBuf, int *pcbNeeded, int *pcReturned);
HWND CreateDialogParamW(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
HRESULT VarBoolFromI2(SHORT sIn, unknown_t *pboolOut);
ATOM RegisterClassExA(unknown_t *ARG_0);
HRESULT OleCreateFontIndirect(LPFONTDESC lpFontDesc, REFIID riid, LPVOID *lplpvObj);
HRESULT VarBoolFromI4(LONG lIn, unknown_t *pboolOut);
HRESULT DllRegisterServer();
CONFIGRET CM_Create_DevNode_ExW(unknown_t pdnDevInst, DEVINSTID_W pDeviceID, DEVINST dnParent, ULONG ulFlags, HMACHINE hMachine);
struct tm * gmtime(time_t *timer);
HRESULT VarBoolFromI8(LONG64 i64In, unknown_t *pboolOut);
HRESULT CoRevokeMallocSpy();
HWND GetDlgItem(HWND hDlg, int nIDDlgItem);
BOOL CryptVerifyDetachedMessageHash(PCRYPT_HASH_MESSAGE_PARA pHashPara, BYTE *pbDetachedHashBlob, DWORD cbDetachedHashBlob, DWORD cToBeHashed, BYTE **rgpbToBeHashed, DWORD *rgcbToBeHashed, BYTE *pbComputedHash, DWORD *pcbComputedHash);
BOOL EnumDisplaySettingsExW(LPCWSTR lpszDeviceName, DWORD iModeNum, unknown_t *lpDevMode, DWORD dwFlags);
BOOL GetTitleBarInfo(HWND hwnd, PTITLEBARINFO pti);
BOOL AddJobW(HPRINTER hPrinter, int Level, unknown_t *pData, int cbBuf, LPDWORD pcbNeeded);
BOOL GradientFill(HDC hdc, unknown_t pVertex, ULONG dwNumVertex, PVOID pMesh, ULONG dwNumMesh, unknown_t dwMode);
BOOL QueryIdleProcessorCycleTimeEx(USHORT Group, PULONG BufferLength, unknown_t ProcessorIdleCycleTime);
HANDLE EnterCriticalPolicySection(BOOL bMachine);
DWORD WSAWaitForMultipleEvents(DWORD cEvents, WSAEVENT *lphEvents, BOOL fWaitAll, DWORD dwTimeout, BOOL fAlertable);
HRESULT SHSetThreadRef(IUnknown *punk);
long GetCharacterPlacementA(HDC hdc, LPCSTR lpString, int nCount, int nMaxExtent, unknown_t lpResults, unknown_t dwFlags);
BOOL EnumDirTree(HANDLE hProcess, PCSTR RootPath, PCSTR InputPathName, PSTR OutputPathBuffer, PENUMDIRTREE_CALLBACK cb, PVOID data);
PVOID FreeSid(PSID pSid);
PWSTR StrRStrIW(PCWSTR pszSource, PCWSTR pszLast, PCWSTR pszSrch);
BOOL CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData);
BOOL EnumJobsW(HPRINTER hPrinter, int FirstJob, int NoJobs, int Level, LPBYTE pJob, int cbBuf, int *pcbNeeded, int *pcReturned);
VOID ber_free(BerElement *pBerElement, INT fbuf);
CONFIGRET CM_Create_DevNode_ExA(unknown_t pdnDevInst, DEVINSTID_A pDeviceID, DEVINST dnParent, ULONG ulFlags, HMACHINE hMachine);
int WPUCloseThread(LPWSATHREADID lpThreadId, LPINT lpErrno);
HRESULT CoAllowSetForegroundWindow(IUnknown *pUnk, LPVOID lpvReserved);
HRESULT DllInstall(BOOL bInstall, PCWSTR pszCmdLine);
BOOL PeekNamedPipe(HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage);
HICON CreateIconFromResourceEx(PBYTE presbits, DWORD dwResSize, BOOL fIcon, DWORD dwVer, int cxDesired, int cyDesired, UINT Flags);
BOOL EnumDisplaySettingsExA(LPCSTR lpszDeviceName, DWORD iModeNum, unknown_t *lpDevMode, DWORD dwFlags);
long SetBkMode(HDC hdc, int iBkMode);
BOOL CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, LPCWSTR pwszDll);
VOID DisableProcessWindowsGhosting();
HENHMETAFILE CopyEnhMetaFileW(HENHMETAFILE hemfSrc, LPCWSTR lpszFile);
BOOL WinHttpReceiveResponse(HINTERNET hRequest, LPVOID lpReserved);
LDAP * ldap_conn_from_msg(LDAP *PrimaryConn, LDAPMessage *res);
long GetCharacterPlacementW(HDC hdc, LPCWSTR lpString, int nCount, int nMaxExtent, unknown_t lpResults, unknown_t dwFlags);
BOOL SetEvent(HANDLE hEvent);
DPI_HOSTING_BEHAVIOR SetThreadDpiHostingBehavior(DPI_HOSTING_BEHAVIOR value);
BOOL QueryProcessCycleTime(HANDLE ProcessHandle, unknown_t CycleTime);
PSTR StrRStrIA(PCSTR pszSource, PCSTR pszLast, PCSTR pszSrch);
HMETAFILE GetMetaFileA();
HINSTANCE FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult);
HENHMETAFILE CopyEnhMetaFileA(HENHMETAFILE hemfSrc, LPCSTR lpszFile);
BOOL ScrollWindow(HWND hWnd, int XAmount, int YAmount, RECT *lpRect, RECT *lpClipRect);
BOOL WriteProfileSectionW(LPCWSTR lpAppName, LPCWSTR lpString);
BOOL OpenPrinterW(LPWSTR pPrinterName, HPRINTER *phPrinter, unknown_t pDefault);
BOOL AllowSetForegroundWindow(DWORD dwProcessId);
HINSTANCE FindExecutableA(LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult);
BOOL CryptSIPRemoveProvider(GUID *pgProv);
LSTATUS RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LPWSTR lpClass, DWORD dwOptions, REGSAM samDesired, const LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition);
CONFIGRET CM_Get_Hardware_Profile_Info_ExA(ULONG ulIndex, unknown_t pHWProfileInfo, ULONG ulFlags, HMACHINE hMachine);
HANDLE ReOpenFile(HANDLE hOriginalFile, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwFlagsAndAttributes);
BOOL WriteProfileSectionA(LPCSTR lpAppName, LPCSTR lpString);
LPARAM SetMessageExtraInfo(LPARAM lParam);
HMETAFILE GetMetaFileW();
ULONG TraceEvent(TRACEHANDLE TraceHandle, PEVENT_TRACE_HEADER EventTrace);
BOOL DeleteMonitorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMonitorName);
BOOL InitiateSystemShutdownA(LPSTR lpMachineName, LPSTR lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown);
LSTATUS RegCreateKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD Reserved, LPSTR lpClass, DWORD dwOptions, REGSAM samDesired, const LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition);
HRESULT VarUI1FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, BYTE *pbOut);
CONFIGRET CM_Get_Hardware_Profile_Info_ExW(ULONG ulIndex, unknown_t pHWProfileInfo, ULONG ulFlags, HMACHINE hMachine);
BOOL CryptSIPRetrieveSubjectGuidForCatalogFile(LPCWSTR FileName, HANDLE hFileIn, GUID *pgSubject);
BOOL OpenPrinterA(LPSTR pPrinterName, HPRINTER *phPrinter, unknown_t pDefault);
WORD GetActiveProcessorGroupCount();
BOOL GetUserObjectInformationW(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength, LPDWORD lpnLengthNeeded);
BOOL GetPointerTouchInfoHistory(UINT32 pointerId, UINT32 *entriesCount, unknown_t *touchInfo);
DWORD GetTempPathW(DWORD nBufferLength, LPWSTR lpBuffer);
BOOL SetThreadToken(PHANDLE Thread, HANDLE Token);
HRESULT UrlApplySchemeA(PCSTR pszIn, PSTR pszOut, DWORD *pcchOut, DWORD dwFlags);
BOOL DeleteObject();
HRESULT AssocQueryStringByKeyW(unknown_t flags, unknown_t str, HKEY hkAssoc, LPCWSTR pszExtra, LPWSTR pszOut, DWORD *pcchOut);
BOOL LockFileEx(HANDLE hFile, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped);
BOOL DeleteMonitorA(LPSTR pName, LPSTR pEnvironment, LPSTR pMonitorName);
void CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay, DWORD dwReserved);
BOOL GetProcessWorkingSetSizeEx(HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize, PDWORD Flags);
bool isunordered(double x, double y);
NTSTATUS NtSetInformationKey(HANDLE KeyHandle, KEY_SET_INFORMATION_CLASS KeySetInformationClass, PVOID KeySetInformation, ULONG KeySetInformationLength);
BOOL InitiateSystemShutdownW(LPWSTR lpMachineName, LPWSTR lpMessage, DWORD dwTimeout, BOOL bForceAppsClosed, BOOL bRebootAfterShutdown);
HRESULT CoGetInstanceFromIStorage(unknown_t *pServerInfo, unknown_t *pClsid, IUnknown *punkOuter, DWORD dwClsCtx, struct IStorage *pstg, DWORD dwCount, unknown_t *pResults);
HRESULT UrlApplySchemeW(PCWSTR pszIn, PWSTR pszOut, DWORD *pcchOut, DWORD dwFlags);
BOOL GetUserObjectInformationA(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength, LPDWORD lpnLengthNeeded);
DWORD GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer);
HRESULT AssocQueryStringByKeyA(unknown_t flags, unknown_t str, HKEY hkAssoc, LPCSTR pszExtra, LPSTR pszOut, DWORD *pcchOut);
CONFIGRET CM_Query_Resource_Conflict_List(unknown_t pclConflictList, DEVINST dnDevInst, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine);
HIMAGELIST ImageList_Duplicate(HIMAGELIST himl);
int SHMessageBoxCheckA(HWND hwnd, LPCSTR pszText, LPCSTR pszCaption, UINT uType, int iDefault, LPCSTR pszRegVal);
INT WSCEnumNameSpaceProvidersEx32(LPDWORD lpdwBufferLength, LPWSANAMESPACE_INFOEXW lpnspBuffer);
BOOL CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
CONFIGRET CM_Get_Device_Interface_Property_KeysW(LPCWSTR pszDeviceInterface, unknown_t *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags);
CONFIGRET CM_Get_Device_Interface_AliasW(LPCWSTR pszDeviceInterface, LPGUID AliasInterfaceGuid, LPWSTR pszAliasDeviceInterface, PULONG pulLength, ULONG ulFlags);
int vprintf(const char *format, va_list ap);
VOID RestoreLastError(DWORD dwErrCode);
CONFIGRET CM_Get_Next_Res_Des_Ex(PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource, PRESOURCEID pResourceID, ULONG ulFlags, HMACHINE hMachine);
PVOID FlsGetValue(DWORD dwFlsIndex);
int GetGeoInfoW(GEOID Location, GEOTYPE GeoType, LPWSTR lpGeoData, int cchData, LANGID LangId);
BOOL CreateScalableFontResourceA(DWORD fdwHidden, LPCSTR lpszFontRes, LPCSTR lpszFontFile, LPCSTR lpszCurrentPath);
int SHMessageBoxCheckW(HWND hwnd, LPCWSTR pszText, LPCWSTR pszCaption, UINT uType, int iDefault, LPCWSTR pszRegVal);
BOOL RectInRegion(HRGN HRGN, RECT *lprc);
BOOL SetDefaultPrinterA();
__attribute__((noreturn)) VOID ExitProcess(UINT uExitCode);
HRESULT Unfreeze();
HRESULT SafeArraySetIID(unknown_t *psa, REFGUID guid);
BOOL CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
int GetGeoInfoA(GEOID Location, GEOTYPE GeoType, LPSTR lpGeoData, int cchData, LANGID LangId);
BOOL SymEnumSourceFiles(HANDLE hProcess, ULONG64 ModBase, PCSTR Mask, PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles, PVOID UserContext);
BOOL CreateScalableFontResourceW(DWORD fdwHidden, LPCWSTR lpszFontRes, LPCWSTR lpszFontFile, LPCWSTR lpszCurrentPath);
BOOL CertFreeCertificateContext(PCCERT_CONTEXT pCertContext);
VOID UnsubscribeServiceChangeNotifications(unknown_t pSubscription);
CONFIGRET CM_Get_Device_Interface_AliasA(LPCSTR pszDeviceInterface, LPGUID AliasInterfaceGuid, LPSTR pszAliasDeviceInterface, PULONG pulLength, ULONG ulFlags);
LSTATUS RegEnumValueA(HKEY hKey, DWORD dwIndex, LPSTR lpValueName, LPDWORD lpcchValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
UINT GetRawInputData(HRAWINPUT hRawInput, UINT uiCommand, LPVOID pData, PUINT pcbSize, UINT cbSizeHeader);
long double atanl(long double x);
BOOL CloseWindowStation(HWINSTA hWinSta);
BOOL SetDefaultPrinterW();
LSTATUS SHRegQueryInfoUSKeyW(HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, unknown_t enumRegFlags);
DWORD K32GetMappedFileNameW(HANDLE hProcess, LPVOID lpv, LPWSTR lpFilename, DWORD nSize);
double atanh(double x);
BOOL SendMessageCallbackW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC lpResultCallBack, ULONG_PTR dwData);
float atanf(float x);
HRESULT IStream_Copy(struct IStream *pstmFrom, struct IStream *pstmTo, DWORD cb);
int fprintf(FILE *stream, const char *format, void *va_args);
LSTATUS RegFlushKey(HKEY hKey);
BOOL CertFindCertificateInCRL(PCCERT_CONTEXT pCert, PCCRL_CONTEXT pCrlContext, DWORD dwFlags, void *pvReserved, PCRL_ENTRY *ppCrlEntry);
DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation);
uintmax_t strtoumax(const char *str, char **endptr, int base);
LSTATUS RegEnumValueW(HKEY hKey, DWORD dwIndex, LPWSTR lpValueName, LPDWORD lpcchValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
NTSTATUS BCryptDuplicateKey(BCRYPT_KEY_HANDLE hKey, BCRYPT_KEY_HANDLE *phNewKey, PUCHAR pbKeyObject, ULONG cbKeyObject, ULONG dwFlags);
VOID FlushProcessWriteBuffers();
const char * setstate(const char *state);
BOOL VirtualProtectEx(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect);
BOOL DisconnectNamedPipe(HANDLE hNamedPipe);
BOOL GetUmsSystemThreadInformation(HANDLE ThreadHandle, PUMS_SYSTEM_THREAD_INFORMATION SystemThreadInfo);
LSTATUS SHRegQueryInfoUSKeyA(HUSKEY hUSKey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen, unknown_t enumRegFlags);
HANDLE CreateMailslotA(LPCSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL GetPointerType(UINT32 pointerId, unknown_t *pointerType);
BOOL SendMessageCallbackA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC lpResultCallBack, ULONG_PTR dwData);
BOOL CertSelectCertificateChains(LPCGUID pSelectionContext, DWORD dwFlags, PCCERT_SELECT_CHAIN_PARA pChainParameters, DWORD cCriteria, PCCERT_SELECT_CRITERIA rgpCriteria, HCERTSTORE hStore, PDWORD pcSelection, PCCERT_CHAIN_CONTEXT **pprgpSelection);
BOOL FileTimeToSystemTime(FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime);
DWORD K32GetMappedFileNameA(HANDLE hProcess, LPVOID lpv, LPSTR lpFilename, DWORD nSize);
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
BOOL TerminateEnclave(LPVOID lpAddress, BOOL fWait);
FILE * tmpfile();
HANDLE GetCurrentThread();
int fgetpos(FILE *stream, fpos_t *pos);
HANDLE CreateMailslotW(LPCWSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL DragQueryPoint(HDROP hDrop, POINT *ppt);
ULONG ldap_compare_ext_s(LDAP *ld, const PSTR dn, const PSTR Attr, const PSTR Value, struct berval *Data, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
HBRUSH CreateDIBPatternBrush(HGLOBAL hglbDIBPacked, unknown_t fuColorSpec);
BOOL GetCharWidthFloatW(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBuffer);
CONFIGRET CM_Get_Device_Interface_List_ExA(LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, PZZSTR Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine);
int GetNumberFormatW(LCID Locale, DWORD dwFlags, LPCWSTR lpValue, unknown_t *lpFormat, LPWSTR lpNumberStr, int cchNumber);
int SetScrollPos(HWND hWnd, int nBar, int nPos, BOOL bRedraw);
long GetClipRgn(HDC hdc, HRGN HRGN);
BOOL AdjustTokenGroups(HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState, DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength);
long double wcstold(wchar_t *nptr, wchar_t **endptr);
BOOL WriteProcessMemory(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T *lpNumberOfBytesWritten);
BOOL LoadStringByReference(DWORD Flags, PCWSTR Language, PCWSTR SourceString, PWSTR Buffer, ULONG cchBuffer, PCWSTR Directory, PULONG pcchBufferOut);
HRESULT VarI2FromCy(unknown_t cyIn, SHORT *psOut);
BOOL DeleteMetaFile();
int fwide(FILE *stream, int mode);
long long wcstoll(wchar_t *nptr, wchar_t **endptr, int base);
BOOL GetCharWidthFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBuffer);
double atan2(double y, double x);
ULONG ber_first_element(BerElement *pBerElement, ULONG *pLen, CHAR **ppOpaque);
int GetNumberFormatA(LCID Locale, DWORD dwFlags, LPCSTR lpValue, unknown_t *lpFormat, LPSTR lpNumberStr, int cchNumber);
HRESULT StgOpenLayoutDocfile(unknown_t *pwcsDfName, DWORD grfMode, DWORD reserved, struct IStorage **ppstgOpen);
CONFIGRET CM_Get_Device_Interface_List_ExW(LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine);
BOOL DrawFocusRect(HDC hDC, RECT *lprc);
HRESULT VarI8FromI2(SHORT sIn, LONG64 *pi64Out);
int WSCDeinstallProvider32(LPGUID lpProviderId, LPINT lpErrno);
HRESULT VarI8FromI1(CHAR cIn, LONG64 *pi64Out);
BOOL GetAclInformation(PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass);
BOOL CredUnPackAuthenticationBufferW(DWORD dwFlags, PVOID pAuthBuffer, DWORD cbAuthBuffer, LPWSTR pszUserName, DWORD *pcchMaxUserName, LPWSTR pszDomainName, DWORD *pcchMaxDomainName, LPWSTR pszPassword, DWORD *pcchMaxPassword);
BOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted);
BOOL WaitCommEvent(HANDLE hFile, LPDWORD lpEvtMask, LPOVERLAPPED lpOverlapped);
VOID GetSystemInfo(LPSYSTEM_INFO lpSystemInfo);
BOOL SymAddSourceStreamW(HANDLE hProcess, ULONG64 Base, PCWSTR FileSpec, PBYTE Buffer, size_t Size);
BOOL SymRegisterCallback(HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK CallbackFunction, PVOID UserContext);
BOOL GetPhysicalCursorPos(LPPOINT lpPoint);
DWORD GetUnpredictedMessagePos();
BOOL GetGestureInfo(unknown_t hGestureInfo, unknown_t pGestureInfo);
int mbsinit(mbstate_t *ps);
BOOL FreeConsole();
HRESULT VarUI1FromDate(unknown_t dateIn, BYTE *pbOut);
long SetMapMode(HDC hdc, unknown_t fnMapMode);
int at_quick_exit();
DWORD PowerWriteACValueIndex(HKEY RootPowerKey, GUID *SchemeGuid, GUID *SubGroupOfPowerSettingsGuid, GUID *PowerSettingGuid, DWORD AcValueIndex);
BOOL EnumProcessModules(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded);
BOOL CertVerifySubjectCertificateContext(PCCERT_CONTEXT pSubject, PCCERT_CONTEXT pIssuer, DWORD *pdwFlags);
LDAPMessage * ldap_next_reference(LDAP *ld, LDAPMessage *entry);
HRESULT VarR4FromDisp(unknown_t *pdispIn, LCID lcid, FLOAT *pfltOut);
HRESULT PathCchRemoveFileSpec(PWSTR pszPath, size_t cchPath);
HRESULT CoMarshalHresult(LPSTREAM pstm, HRESULT hresult);
HRESULT BstrFromVector(unknown_t *psa, BSTR *pbstr);
HRESULT IStream_Write(struct IStream *pstm, const void *pv, ULONG cb);
void ClearCustData(LPCUSTDATA pCustData);
BOOL IsImmersiveProcess(HANDLE hProcess);
int fesetround(int round);
int ExtEscape(HDC hdc, unknown_t escapeCode, int cbInput, LPSTR pszInData, int cbOutput, LPSTR lpszOutData);
BOOL CredUnPackAuthenticationBufferA(DWORD dwFlags, PVOID pAuthBuffer, DWORD cbAuthBuffer, LPSTR pszUserName, DWORD *pcchlMaxUserName, LPSTR pszDomainName, DWORD *pcchMaxDomainName, LPSTR pszPassword, DWORD *pcchMaxPassword);
ULONG ldap_modify(LDAP *ld, PSTR dn, unknown_t **mods);
ULONG EventAccessQuery(LPGUID Guid, PSECURITY_DESCRIPTOR Buffer, PULONG BufferSize);
BOOL SetCursorPos(int X, int Y);
BOOL FixBrushOrgEx(HDC hdc, int arg1, int arg2, LPPOINT point);
ULONG RemoveTraceCallback(LPCGUID pGuid);
wint_t towlower(wint_t wc);
BOOLEAN WTSIsServerContainer();
BOOL TranslateMessage(unknown_t *lpMsg);
bool islessgreater(double x, double y);
HRESULT StringFromCLSID(unknown_t rclsid, LPOLESTR *lplpsz);
BOOL WinHttpSetCredentials(HINTERNET hRequest, DWORD AuthTargets, DWORD AuthScheme, LPCWSTR pwszUserName, LPCWSTR pwszPassword, LPVOID pAuthParams);
BOOL SymFindFileInPath(HANDLE hprocess, PCSTR SearchPath, PCSTR FileName, PVOID id, DWORD two, DWORD three, DWORD flags, PSTR FoundFile, PFINDFILEINPATHCALLBACK callback, PVOID context);
int LookupIconIdFromDirectory(PBYTE presbits, BOOL fIcon);
BOOL WinHttpSetTimeouts(HINTERNET hInternet, int nResolveTimeout, int nConnectTimeout, int nSendTimeout, int nReceiveTimeout);
HRESULT StgGetIFillLockBytesOnFile(unknown_t *pwcsName, unknown_t **ppflb);
CONFIGRET CM_Modify_Res_Des(PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags);
BOOL GetServiceDisplayNameW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, LPDWORD lpcchBuffer);
HRESULT CoGetObjectContext(REFIID riid, LPVOID *ppv);
HRESULT VarBoolFromCy(unknown_t cyIn, unknown_t *pboolOut);
long BroadcastSystemMessageW(DWORD flags, LPDWORD lpInfo, UINT Msg, WPARAM wParam, LPARAM lParam);
float copysignf(float x, float y);
HRESULT VarParseNumFromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, unknown_t *pnumprs, BYTE *rgbDig);
BOOL GetServiceDisplayNameA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPDWORD lpcchBuffer);
float nextafterf(float x, float y);
HRESULT SetProcessDpiAwareness(PROCESS_DPI_AWARENESS value);
BOOL PostMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
HRESULT UrlGetPartA(PCSTR pszIn, PSTR pszOut, DWORD *pcchOut, DWORD dwPart, DWORD dwFlags);
CONFIGRET CM_Add_Res_Des(PRES_DES prdResDes, unknown_t lcLogConf, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags);
BOOL WritePrinter(HPRINTER hPrinter, LPVOID pBuf, int cbBuf, LPDWORD pcWritten);
PCCRL_CONTEXT CertFindCRLInStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, DWORD dwFindFlags, DWORD dwFindType, const void *pvFindPara, PCCRL_CONTEXT pPrevCrlContext);
long double copysignl(long double x, long double y);
long double nextafterl(long double x, long double y);
long BroadcastSystemMessageA(DWORD flags, LPDWORD lpInfo, UINT Msg, WPARAM wParam, LPARAM lParam);
CONFIGRET CM_Add_Range(DWORDLONG ullStartValue, DWORDLONG ullEndValue, unknown_t rlh, ULONG ulFlags);
HRESULT UrlGetPartW(PCWSTR pszIn, PWSTR pszOut, DWORD *pcchOut, DWORD dwPart, DWORD dwFlags);
BOOL CryptCreateKeyIdentifierFromCSP(DWORD dwCertEncodingType, LPCSTR pszPubKeyOID, unknown_t *pPubKeyStruc, DWORD cbPubKeyStruc, DWORD dwFlags, void *pvReserved, BYTE *pbHash, DWORD *pcbHash);
BOOL PathIsUNCEx(PCWSTR pszPath, PCWSTR *ppszServer);
BOOL MoveFileTransactedW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags, HANDLE hTransaction);
BOOL EnumPrinterDataExW(HPRINTER hPrinter, LPWSTR pKeyName, LPBYTE pEnumValues, int cbEnumValues, int *pcbEnumValues, int *pnEnumValues);
HRESULT RegisterApplicationRestart(PCWSTR pwzCommandline, DWORD dwFlags);
HRESULT DllGetClassObject(unknown_t rclsid, REFIID riid, LPVOID *ppv);
BOOL GetVolumePathNamesForVolumeNameW(LPCWSTR lpszVolumeName, LPWCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength);
BOOL NotifyChangeEventLog(HANDLE hEventLog, HANDLE hEvent);
HRGN CreateRoundRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect, int nWidthEllipse, int nHeightEllipse);
BOOL SetProcessWorkingSetSizeEx(HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize, DWORD Flags);
NTSTATUS BCryptDeleteContext(ULONG dwTable, LPCWSTR pszContext);
BOOL DeleteProfileW(LPCWSTR lpSidString, LPCWSTR lpProfilePath, LPCWSTR lpComputerName);
void GetEffectiveClientRect(HWND hWnd, LPRECT lprc, INT *lpInfo);
BOOL PostMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
USHORT RtlCaptureStackBackTrace(ULONG FramesToSkip, ULONG FramesToCapture, PVOID *BackTrace, PULONG BackTraceHash);
BOOL VirtualUnlockEx(HANDLE Process, LPVOID Address, SIZE_T Size);
int recvfrom(SOCKET s, char *buf, int len, int flags, struct sockaddr *from, int *fromlen);
DWORD CredUIReadSSOCredW(PCWSTR pszRealm, PWSTR *ppszUsername);
LPVOID MapViewOfFileExNuma(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress, DWORD nndPreferred);
HRESULT SafeArrayGetLBound(unknown_t *psa, UINT nDim, LONG *plLbound);
LSTATUS SHRegDeleteUSValueW(HUSKEY hUSKey, LPCWSTR pwzValue, unknown_t delRegFlags);
BOOL SearchTreeForFileW(PCWSTR RootPath, PCWSTR InputPathName, PWSTR OutputPathBuffer);
HRESULT GetExtent(DWORD dwDrawAspect, LONG lindex, unknown_t *ptd, unknown_t lpsizel);
BOOL QueryCompressorInformation(COMPRESSOR_HANDLE CompressorHandle, COMPRESS_INFORMATION_CLASS CompressInformationClass, PVOID CompressInformation, SIZE_T CompressInformationSize);
HMETAFILE SetMetaFileBitsEx(UINT nSize, BYTE *lpData);
BOOL EnumPrinterDataExA(HPRINTER hPrinter, LPSTR pKeyName, LPBYTE pEnumValues, int cbEnumValues, int *pcbEnumValues, int *pnEnumValues);
BOOL GetTextExtentPoint32W(HDC hdc, LPCWSTR lpString, int cbString, LPSIZE lpSize);
BOOL AppendMenuW(HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem);
HRESULT IStream_WriteStr(struct IStream *pstm, PCWSTR psz);
HRESULT VarDecFix(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
BOOL MoveFileTransactedA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags, HANDLE hTransaction);
BOOL GetVolumePathNamesForVolumeNameA(LPCSTR lpszVolumeName, LPCH lpszVolumePathNames, DWORD cchBufferLength, PDWORD lpcchReturnLength);
ULONG AVIFileAddRef();
ULONG ldap_set_option(LDAP *ld, int option, const void *invalue);
BOOL DeleteProfileA(LPCSTR lpSidString, LPCSTR lpProfilePath, LPCSTR lpComputerName);
BOOL AppendMenuA(HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem);
HWND CreateWindowExW(DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam);
LSTATUS SHRegDeleteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, unknown_t delRegFlags);
wchar_t * wmemchr(wchar_t *s, wchar_t c, size_t n);
BOOL BringWindowToTop(HWND hWnd);
double ceil(double x);
BOOL ScaleWindowExtEx(HDC hdc, int Xnum, int Xdenom, int Ynum, int Ydenom, LPSIZE lpSize);
HWINSTA GetProcessWindowStation();
BOOL GetTextExtentPoint32A(HDC hdc, LPCSTR lpString, int cbString, LPSIZE lpSize);
HWND CreateWindowExA(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam);
CONFIGRET CM_Free_Log_Conf_Handle(unknown_t lcLogConf);
HRESULT IsDirty();
HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId);
HANDLE RegisterEventSourceW(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName);
DWORD CredUIParseUserNameA(PCSTR userName, CHAR *user, ULONG userBufferSize, CHAR *domain, ULONG domainBufferSize);
BOOL DeletePrintProvidorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPrintProvidorName);
LPAPI_VERSION ImagehlpApiVersionEx(LPAPI_VERSION AppVersion);
DWORD GetKerningPairsW(HDC hdc, DWORD nNumPairs, unknown_t lpkrnpair);
NTSTATUS BCryptRegisterConfigChangeNotify(PRKEVENT pEvent);
DPI_AWARENESS_CONTEXT GetThreadDpiAwarenessContext();
NTSTATUS BCryptConfigureContextFunction(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, PCRYPT_CONTEXT_FUNCTION_CONFIG pConfig);
BOOL SetJobA(HPRINTER hPrinter, DWORD JobId, int Level, LPBYTE pJob, DWORD Command);
BOOL DeletePrintProvidorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProvidorName);
BOOL FindFirstFreeAce(PACL pAcl, LPVOID *pAce);
DWORD GetKerningPairsA(HDC hdc, DWORD nNumPairs, unknown_t lpkrnpair);
BOOL EmptyWorkingSet(HANDLE hProcess);
HANDLE RegisterEventSourceA(LPCSTR lpUNCServerName, LPCSTR lpSourceName);
DWORD CredUIParseUserNameW(PCWSTR UserName, WCHAR *user, ULONG userBufferSize, WCHAR *domain, ULONG domainBufferSize);
PCSTR SymSrvStoreFile(HANDLE hProcess, PCSTR SrvPath, PCSTR File, DWORD Flags);
LDAP * cldap_openW(PWSTR HostName, ULONG PortNumber);
int GetHostNameW(PWSTR name, int namelen);
BOOL FlashWindow(HWND hWnd, BOOL bInvert);
BOOL ResetCompressor(COMPRESSOR_HANDLE CompressorHandle);
LONG _llseek(HFILE hFile, LONG lOffset, int iOrigin);
BOOL SetJobW(HPRINTER hPrinter, DWORD JobId, int Level, LPBYTE pJob, DWORD Command);
PVOID LocateXStateFeature(PCONTEXT Context, DWORD FeatureId, PDWORD Length);
BOOL SetProcessInformation(HANDLE hProcess, PROCESS_INFORMATION_CLASS ProcessInformationClass, LPVOID ProcessInformation, DWORD ProcessInformationSize);
ULONG EnumerateTraceGuids(PTRACE_GUID_PROPERTIES *GuidPropertiesArray, ULONG PropertyArrayCount, PULONG GuidCount);
LDAP * cldap_openA(PSTR HostName, ULONG PortNumber);
HRESULT PathCchRemoveBackslash(PWSTR pszPath, size_t cchPath);
BOOL EnumMonitorsA(LPSTR pName, int Level, LPBYTE pMonitors, int cbBuf, int *pcbNeeded, int *pcReturned);
HANDLE WSAAsyncGetProtoByNumber(HWND hWnd, u_int wMsg, int number, char *buf, int buflen);
VOID AcquireSRWLockShared(PSRWLOCK SRWLock);
CONFIGRET CM_Set_Device_Interface_Property_ExW(LPCWSTR pszDeviceInterface, unknown_t *PropertyKey, unknown_t PropertyType, PBYTE PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine);
BOOL IsValidCodePage(UINT CodePage);
DWORD Wow64SuspendThread(HANDLE hThread);
BOOL GetPrivateProfileStructA(LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile);
wint_t putwchar(wchar_t c);
HRESULT VarR8FromCy(unknown_t cyIn, DOUBLE *pdblOut);
void warn(const char *format);
BOOL ClearCommBreak(HANDLE hFile);
NTSTATUS BCryptDuplicateHash(BCRYPT_HASH_HANDLE hHash, BCRYPT_HASH_HANDLE *phNewHash, PUCHAR pbHashObject, ULONG cbHashObject, ULONG dwFlags);
UINT SetErrorMode(UINT uMode);
DWORD VerFindFileA(DWORD uFlags, LPCSTR szFileName, LPCSTR szWinDir, LPCSTR szAppDir, LPSTR szCurDir, PUINT puCurDirLen, LPSTR szDestDir, PUINT puDestDirLen);
HRESULT SHGetItemFromObject(IUnknown *punk, REFIID riid, void **ppv);
HRESULT VarDecFromUI8(ULONG64 ui64In, DECIMAL *pdecOut);
__uint64 ntohll(__uint64 Value);
DWORD VerFindFileW(DWORD uFlags, LPCWSTR szFileName, LPCWSTR szWinDir, LPCWSTR szAppDir, LPWSTR szCurDir, PUINT puCurDirLen, LPWSTR szDestDir, PUINT puDestDirLen);
void PathRemoveArgsA(LPSTR pszPath);
BOOL GetPrivateProfileStructW(LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile);
void SHAddToRecentDocs(unknown_t uFlags, LPCVOID pv);
BOOL CertRegisterSystemStore(const void *pvSystemStore, DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo, void *pvReserved);
DWORD GetEnhMetaFilePixelFormat(HENHMETAFILE hemf, DWORD cbBuffer, unknown_t *ppfd);
BOOL EnumMonitorsW(LPWSTR pName, int Level, LPBYTE pMonitors, int cbBuf, int *pcbNeeded, int *pcReturned);
HRESULT VarDecFromUI1(BYTE bIn, DECIMAL *pdecOut);
HRESULT VarDecFromUI2(USHORT uiIn, DECIMAL *pdecOut);
LONG DisplayConfigSetDeviceInfo(unknown_t *setPacket);
VOID DeleteFiber(LPVOID lpFiber);
HRESULT VarDecFromUI4(ULONG ulIn, DECIMAL *pdecOut);
BOOL CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash);
long GetPath(HDC hdc, LPPOINT lpPoints, unknown_t *lpTypes, int nSize);
FARPROC GetProcAddress(HMODULE hModule, LPCSTR lpProcName);
BOOL SymFromToken(HANDLE hProcess, DWORD64 Base, DWORD Token, PSYMBOL_INFO Symbol);
HRESULT SHQueryRecycleBinW(LPCWSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo);
HRESULT PathCchCombineEx(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn, PCWSTR pszMore, ULONG dwFlags);
float roundf(float x);
DWORD PowerUnregisterSuspendResumeNotification(HPOWERNOTIFY RegistrationHandle);
DWORD EnumDynamicTimeZoneInformation(DWORD dwIndex, PDYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation);
NTSTATUS RtlAddGrowableFunctionTable(PVOID *DynamicTable, PRUNTIME_FUNCTION FunctionTable, ULONG EntryCount, ULONG MaximumEntryCount, ULONG_PTR RangeBase, ULONG_PTR RangeEnd);
int wmemcmp(wchar_t *s1, wchar_t *s2, size_t n);
int send(SOCKET s, const char *buf, int len, int flags);
void PathRemoveArgsW(LPWSTR pszPath);
long double roundl(long double x);
HRESULT IUnknown_QueryService(IUnknown *punk, REFGUID guidService, REFIID riid, void **ppvOut);
PCWSTR SymSrvGetSupplementW(HANDLE hProcess, PCWSTR SymPath, PCWSTR Node, PCWSTR File);
BOOL QueryIdleProcessorCycleTime(PULONG BufferLength, unknown_t ProcessorIdleCycleTime);
PCWSTR SymSrvDeltaNameW(HANDLE hProcess, PCWSTR SymPath, PCWSTR Type, PCWSTR File1, PCWSTR File2);
HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName);
DWORD GetPrivateProfileStringA(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName);
PVOID DecodePointer(PVOID Ptr);
DWORD ProcessGroupPolicyCompleted(unknown_t extensionId, unknown_t pAsyncHandle, DWORD dwStatus);
NTSTATUS BCryptQueryContextConfiguration(ULONG dwTable, LPCWSTR pszContext, ULONG *pcbBuffer, PCRYPT_CONTEXT_CONFIG *ppBuffer);
HRESULT SHCreateShellItemArrayFromIDLists(UINT cidl, unknown_t rgpidl, unknown_t **ppsiItemArray);
DWORD GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize);
DWORD GetFontData(HDC hdc, DWORD dwTable, DWORD dwOffset, LPVOID lpvBuffer, DWORD cbData);
BOOL IsBadCodePtr(FARPROC lpfn);
HRESULT SHQueryRecycleBinA(LPCSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo);
BOOL CryptSIPAddProvider(unknown_t *psNewProv);
HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName);
BOOL SetThreadPreferredUILanguages(DWORD dwFlags, PCZZWSTR pwszLanguagesBuffer, PULONG pulNumLanguages);
BOOL GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType, PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Buffer, PDWORD ReturnedLength);
double nearbyint(double x);
int GetWindowRgnBox(HWND hWnd, LPRECT lprc);
BOOL SetConsoleTextAttribute(HANDLE hConsoleOutput, WORD wAttributes);
BOOL DisableThreadLibraryCalls(HMODULE hLibModule);
UINT SafeArrayGetElemsize(unknown_t *psa);
DWORD K32GetProcessImageFileNameW(HANDLE hProcess, LPWSTR lpImageFileName, DWORD nSize);
VOID RtlDeleteGrowableFunctionTable(PVOID DynamicTable);
BOOL GetPointerDevice(HANDLE device, unknown_t *pointerDevice);
BOOL SymEnumSourceLinesW(HANDLE hProcess, ULONG64 Base, PCWSTR Obj, PCWSTR File, DWORD Line, DWORD Flags, PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, PVOID UserContext);
DWORD GetPrivateProfileStringW(LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName);
BOOL SetFileShortNameW(HANDLE hFile, LPCWSTR lpShortName);
LONG ChangeDisplaySettingsExA(LPCSTR lpszDeviceName, unknown_t *lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
BOOL GetConsoleMode(HANDLE hConsoleHandle, LPDWORD lpMode);
DWORD GetListBoxInfo(HWND hwnd);
HRESULT SHQueryUserNotificationState(unknown_t *pquns);
DWORD GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSize);
HRESULT OleLoadPictureFile(VARIANT varFileName, LPDISPATCH *lplpdispPicture);
CONFIGRET CM_Set_HW_Prof(ULONG ulHardwareProfile, ULONG ulFlags);
BOOL CopyContext(PCONTEXT Destination, DWORD ContextFlags, PCONTEXT Source);
HRESULT VarCyRound(unknown_t cyIn, int cDecimals, unknown_t pcyResult);
HRESULT Invoke(unknown_t dispIdMember, REFIID riid, LCID lcid, WORD wFlags, unknown_t *pDispParams, VARIANT *pVarResult, unknown_t *pExcepInfo, UINT *puArgErr);
void MenuHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, HMENU hMainMenu, HINSTANCE hInst, HWND hwndStatus, UINT *lpwIDs);
BOOL SetComputerNameA(LPCSTR lpComputerName);
DWORD K32GetProcessImageFileNameA(HANDLE hProcess, LPSTR lpImageFileName, DWORD nSize);
BOOL GetVolumeInformationW(LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize);
BOOL GetFileVersionInfoA(LPCSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
HRESULT VarI8FromR4(FLOAT fltIn, LONG64 *pi64Out);
ULONG ldap_msgfree(LDAPMessage *res);
BOOL WPUResetEvent(WSAEVENT hEvent, LPINT lpErrno);
BOOL EscapeCommFunction(HANDLE hFile, DWORD dwFunc);
BOOL SetFileShortNameA(HANDLE hFile, LPCSTR lpShortName);
DWORD GetLogicalDriveStringsW(DWORD nBufferLength, LPWSTR lpBuffer);
BOOL SymEnumSourceFileTokens(HANDLE hProcess, ULONG64 Base, PENUMSOURCEFILETOKENSCALLBACK Callback);
BOOL LocalFileTimeToFileTime(FILETIME *lpLocalFileTime, LPFILETIME lpFileTime);
BOOL SetComputerNameW(LPCWSTR lpComputerName);
LONG ChangeDisplaySettingsExW(LPCWSTR lpszDeviceName, unknown_t *lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
LSTATUS RegQueryInfoKeyA(HKEY hKey, LPSTR lpClass, LPDWORD lpcchClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxClassLen, LPDWORD lpcValues, LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime);
int FillRect(HDC hDC, RECT *lprc, HBRUSH hbr);
BOOL CredGetSessionTypes(DWORD MaximumPersistCount, LPDWORD MaximumPersist);
HRESULT VarI8FromR8(DOUBLE dblIn, LONG64 *pi64Out);
BOOL VerifyScripts(DWORD dwFlags, LPCWSTR lpLocaleScripts, int cchLocaleScripts, LPCWSTR lpTestScripts, int cchTestScripts);
HRESULT CreateInstance(IUnknown *pUnkOuter, REFIID riid, unknown_t *ppvObject);
LPWSTR * CommandLineToArgvW(LPCWSTR lpCmdLine, int *pNumArgs);
PCHAR ldap_get_dn(LDAP *ld, LDAPMessage *entry);
DWORD GetLogicalDriveStringsA(DWORD nBufferLength, LPSTR lpBuffer);
LSTATUS RegQueryInfoKeyW(HKEY hKey, LPWSTR lpClass, LPDWORD lpcchClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxClassLen, LPDWORD lpcValues, LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime);
ULONG ldap_add_ext(LDAP *ld, const PSTR dn, unknown_t **attrs, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
BOOL GetVolumeInformationA(LPCSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize);
BOOL GetFileVersionInfoW(LPCWSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
DWORD GetPrivateProfileSectionW(LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName);
LONG GetMenuCheckMarkDimensions();
int fileno(FILE *stream);
BOOL UnmapViewOfFileEx(PVOID BaseAddress, ULONG UnmapFlags);
int UrlCompareA(PCSTR psz1, PCSTR psz2, BOOL fIgnoreSlash);
NTSTATUS NtCreateFile(PHANDLE FileHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PIO_STATUS_BLOCK IoStatusBlock, PLARGE_INTEGER AllocationSize, ULONG FileAttributes, ULONG ShareAccess, ULONG CreateDisposition, ULONG CreateOptions, PVOID EaBuffer, ULONG EaLength);
BOOL CertAddCertificateLinkToStore(HCERTSTORE hCertStore, PCCERT_CONTEXT pCertContext, DWORD dwAddDisposition, PCCERT_CONTEXT *ppStoreContext);
int GetTextCharacterExtra(HDC hdc);
void DragAcceptFiles(HWND hWnd, BOOL fAccept);
BOOL CertFreeCRLContext(PCCRL_CONTEXT pCrlContext);
DWORD GetPrivateProfileSectionA(LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName);
DWORD GetThreadErrorMode();
ULONG ldap_parse_extended_resultW(LDAP *Connection, LDAPMessage *ResultMessage, PWSTR *ResultOID, struct berval **ResultData, BOOLEAN Freeit);
PSTR StrChrIA(PCSTR pszStart, WORD wMatch);
BOOL ConvertToAutoInheritPrivateObjectSecurity(PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CurrentSecurityDescriptor, PSECURITY_DESCRIPTOR *NewSecurityDescriptor, GUID *ObjectType, BOOLEAN IsDirectoryObject, PGENERIC_MAPPING GenericMapping);
CONFIGRET CM_Free_Log_Conf_Ex(unknown_t lcLogConfToBeFreed, ULONG ulFlags, HMACHINE hMachine);
ULONG ldap_parse_extended_resultA(LDAP *Connection, LDAPMessage *ResultMessage, PSTR *ResultOID, struct berval **ResultData, BOOLEAN Freeit);
int UrlCompareW(PCWSTR psz1, PCWSTR psz2, BOOL fIgnoreSlash);
CONFIGRET CM_Create_Range_List(unknown_t prlh, ULONG ulFlags);
LPVOID CryptMemRealloc(LPVOID pv, ULONG cbSize);
HRESULT CoRegisterSurrogate(LPSURROGATE pSurrogate);
BOOL CheckRadioButton(HWND hDlg, int nIDFirstButton, int nIDLastButton, int nIDCheckButton);
SOCKET socket(int af, int type, int protocol);
int GetKeyboardType(int nTypeFlag);
BOOL GetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize);
DWORD GetMaximumProcessorCount(WORD GroupNumber);
PWSTR StrChrIW(PCWSTR pszStart, WCHAR wMatch);
BOOL SymGetScope(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, PSYMBOL_INFO Symbol);
COLORREF SetDCBrushColor(HDC hdc, COLORREF crColor);
HRESULT SetAdvise(DWORD aspects, DWORD advf, unknown_t *pAdvSink);
BOOL CryptHashToBeSigned(HCRYPTPROV_LEGACY hCryptProv, DWORD dwCertEncodingType, BYTE *pbEncoded, DWORD cbEncoded, BYTE *pbComputedHash, DWORD *pcbComputedHash);
BOOL ClosePrinter();
BOOL GetComputerNameA(LPSTR lpBuffer, LPDWORD nSize);
VOID PostQuitMessage(int nExitCode);
LSTATUS RegRestoreKeyA(HKEY hKey, LPCSTR lpFile, DWORD dwFlags);
int PathParseIconLocationA(LPSTR pszIconFile);
ATOM DeleteAtom(ATOM nAtom);
BOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent, PACL *pDacl, LPBOOL lpbDaclDefaulted);
BOOL AddScopedPolicyIDAce(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid);
PVOID MapViewOfFile3FromApp(HANDLE FileMapping, HANDLE Process, PVOID BaseAddress, ULONG64 Offset, SIZE_T ViewSize, ULONG AllocationType, ULONG PageProtection, unknown_t *ExtendedParameters, ULONG ParameterCount);
BOOL SymEnumSymbolsForAddr(HANDLE hProcess, DWORD64 Address, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
BOOL CryptSIPVerifyIndirectData(unknown_t *pSubjectInfo, unknown_t *pIndirectData);
NTSTATUS BCryptCloseAlgorithmProvider(BCRYPT_ALG_HANDLE hAlgorithm, ULONG dwFlags);
int EnumFontFamiliesExA(HDC hdc, unknown_t lpLogfont, unknown_t lpEnumFontFamExProc, LPARAM lParam, DWORD dwFlags);
BOOL EndTask(HWND hWnd, BOOL fShutDown, BOOL fForce);
LSTATUS RegRestoreKeyW(HKEY hKey, LPCWSTR lpFile, DWORD dwFlags);
HRESULT VarUI2FromDec(DECIMAL *pdecIn, USHORT *puiOut);
HRESULT VarDecMul(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
int PathParseIconLocationW(LPWSTR pszIconFile);
int putchar(int c);
BOOL GetIconInfo(HICON hIcon, PICONINFO piconinfo);
BOOL SymGetLineFromName(HANDLE hProcess, PCSTR ModuleName, PCSTR FileName, DWORD dwLineNumber, PLONG plDisplacement, PIMAGEHLP_LINE Line);
HWND GetNextDlgGroupItem(HWND hDlg, HWND hCtl, BOOL bPrevious);
CONFIGRET CM_Get_DevNode_PropertyW(DEVINST dnDevInst, unknown_t *PropertyKey, unknown_t *PropertyType, PBYTE PropertyBuffer, PULONG PropertyBufferSize, ULONG ulFlags);
DWORD SHGetAssocKeys(unknown_t *pqa, HKEY *rgKeys, DWORD cKeys);
DWORD SymLoadModule(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD BaseOfDll, DWORD SizeOfDll);
BOOL GetCommMask(HANDLE hFile, LPDWORD lpEvtMask);
__attribute__((noreturn)) VOID ExitThread(DWORD dwExitCode);
int EnumFontFamiliesExW(HDC hdc, unknown_t lpLogfont, unknown_t lpEnumFontFamExProc, LPARAM lParam, DWORD dwFlags);
ULONG ldap_get_next_page(PLDAP ExternalHandle, PLDAPSearch SearchHandle, ULONG PageSize, ULONG *MessageNumber);
wint_t fputwc(wchar_t c, FILE *stream);
BOOL RemoveDirectoryTransactedA(LPCSTR lpPathName, HANDLE hTransaction);
void free(void *ptr);
HWND FindWindowExW(HWND hWndParent, HWND hWndChildAfter, LPCWSTR lpszClass, LPCWSTR lpszWindow);
BOOL CM_Is_Version_Available(WORD wVersion);
BOOL CryptEnumProviderTypesW(DWORD dwIndex, DWORD *pdwReserved, DWORD dwFlags, DWORD *pdwProvType, LPWSTR szTypeName, DWORD *pcbTypeName);
BOOL CryptSetKeyParam(HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData, DWORD dwFlags);
BOOL EnumResourceLanguagesExA(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROCA lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
BOOL GetMenuInfo(HMENU ARG_0, LPMENUINFO ARG_1);
CONFIGRET CM_Set_Class_PropertyW(LPCGUID ClassGUID, unknown_t *PropertyKey, unknown_t PropertyType, PBYTE PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags);
BOOL RemoveDirectoryTransactedW(LPCWSTR lpPathName, HANDLE hTransaction);
void perror(const char *s);
HWND FindWindowExA(HWND hWndParent, HWND hWndChildAfter, LPCSTR lpszClass, LPCSTR lpszWindow);
BOOL CryptEnumProviderTypesA(DWORD dwIndex, DWORD *pdwReserved, DWORD dwFlags, DWORD *pdwProvType, LPSTR szTypeName, DWORD *pcbTypeName);
char * basename(char *path);
CONFIGRET CM_Enable_DevNode_Ex(DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
HPALETTE SelectPalette(HDC hdc, HPALETTE hpal, BOOL bForceBackground);
int fputws(wchar_t *s, FILE *stream);
char * strcpy(char *dest, const char *src);
BOOL BindIoCompletionCallback(HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags);
BOOL CheckMenuRadioItem(HMENU hmenu, UINT first, UINT last, UINT check, UINT flags);
HRESULT VarI2FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, SHORT *psOut);
BOOL SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath);
BOOL EnumResourceLanguagesExW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROCW lpEnumFunc, LONG_PTR lParam, DWORD dwFlags, LANGID LangId);
HRESULT CreateBindCtx(DWORD reserved, unknown_t *ppbc);
SIZE_T LocalCompact(UINT uMinFree);
DWORD CharLowerBuffA(LPSTR lpsz, DWORD cchLength);
BOOL LoadEnclaveData(HANDLE hProcess, LPVOID lpAddress, LPCVOID lpBuffer, SIZE_T nSize, DWORD flProtect, LPCVOID lpPageInformation, DWORD dwInfoLength, PSIZE_T lpNumberOfBytesWritten, LPDWORD lpEnclaveError);
DWORD CertEnumCertificateContextProperties(PCCERT_CONTEXT pCertContext, DWORD dwPropId);
BOOL RegisterRawInputDevices(PCRAWINPUTDEVICE pRawInputDevices, UINT uiNumDevices, UINT cbSize);
int DlgDirListW(HWND hDlg, LPWSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType);
BOOL FlushConsoleInputBuffer(HANDLE hConsoleInput);
PWSTR StrChrNW(PCWSTR pszStart, WCHAR wMatch, UINT cchMax);
BOOL CancelDC();
HRESULT CoSwitchCallContext(IUnknown *pNewObject, IUnknown **ppOldObject);
BOOL GetProcessPreferredUILanguages(DWORD dwFlags, PULONG pulNumLanguages, PZZWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer);
BOOL SymSetParentWindow(HWND hwnd);
HOOKPROC SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc);
PWSTR StrFormatKBSizeW(LONGLONG qdw, PWSTR pszBuf, UINT cchBuf);
BOOL CryptGetKeyIdentifierProperty(unknown_t *pKeyIdentifier, DWORD dwPropId, DWORD dwFlags, LPCWSTR pwszComputerName, void *pvReserved, void *pvData, DWORD *pcbData);
BOOL SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath);
HANDLE RemovePropW(HWND hWnd, LPCWSTR lpString);
ULONG SymGetFileLineOffsets64(HANDLE hProcess, PCSTR ModuleName, PCSTR FileName, PDWORD64 Buffer, ULONG BufferLines);
BOOL SetProcessWorkingSetSize(HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize);
ULONG RtlUniform(PULONG Seed);
int LdapUTF8ToUnicode(LPCSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest);
PCCRYPT_OID_INFO CryptFindOIDInfo(DWORD dwKeyType, void *pvKey, DWORD dwGroupId);
BOOL ChrCmpIA(WORD w1, WORD w2);
UINT_PTR SetTimer(HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, unknown_t lpTimerFunc);
DWORD CharLowerBuffW(LPWSTR lpsz, DWORD cchLength);
HOOKPROC SetWindowsHookA(int nFilterType, HOOKPROC pfnFilterProc);
int DlgDirListA(HWND hDlg, LPSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType);
size_t wcscspn(wchar_t *s1, wchar_t *s2);
int WSCInstallProvider(LPGUID lpProviderId, WCHAR *lpszProviderDllPath, const LPWSAPROTOCOL_INFOW lpProtocolInfoList, DWORD dwNumberOfEntries, LPINT lpErrno);
NTSTATUS NtDeviceIoControlFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG IoControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength);
int getpeername(SOCKET s, struct sockaddr *name, int *namelen);
DWORD GetProcessIdOfThread(HANDLE Thread);
HRESULT GetClassID();
BOOL MapUserPhysicalPages(PVOID VirtualAddress, ULONG_PTR NumberOfPages, PULONG_PTR PageArray);
CONFIGRET CM_Get_DevNode_Custom_PropertyW(DEVINST dnDevInst, PCWSTR pszCustomPropertyName, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
PSTR StrFormatKBSizeA(LONGLONG qdw, PSTR pszBuf, UINT cchBuf);
BOOL Shell_NotifyIcon(unknown_t dwMessage, unknown_t pnid);
UINT GetSystemPaletteEntries(HDC hdc, UINT iStartIndex, UINT nEntries, unknown_t lppe);
HANDLE RemovePropA(HWND hWnd, LPCSTR lpString);
void PathUndecorateW(LPWSTR pszPath);
int StrSpnW(PCWSTR psz, PCWSTR pszSet);
CONFIGRET CM_Get_Class_Property_Keys(LPCGUID ClassGUID, unknown_t *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags);
HRESULT HIMAGELIST_QueryInterface(HIMAGELIST himl, REFIID riid, void **ppv);
BOOL ChrCmpIW(WCHAR w1, WCHAR w2);
HRESULT SHStrDupA(LPCSTR psz, LPWSTR *ppwsz);
BOOL StartServiceW(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCWSTR *lpServiceArgVectors);
char * tgoto(const char *cap, int col, int row);
BOOL GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo);
COLORREF GetNearestColor(HDC hdc, COLORREF crColor);
BOOL CryptSIPCreateIndirectData(unknown_t *pSubjectInfo, DWORD *pcbIndirectData, unknown_t *pIndirectData);
ULONG EventActivityIdControl(ULONG ControlCode, LPGUID ActivityId);
void PathUndecorateA(LPSTR pszPath);
CONFIGRET CM_Get_DevNode_Custom_PropertyA(DEVINST dnDevInst, PCSTR pszCustomPropertyName, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
int StrSpnA(PCSTR psz, PCSTR pszSet);
HRESULT SHStrDupW(LPCWSTR psz, LPWSTR *ppwsz);
BOOL StartServiceA(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCSTR *lpServiceArgVectors);
unsigned long inet_addr(const char *cp);
UINT GetMenuItemID(HMENU hMenu, int nPos);
NTSTATUS BCryptSetContextFunctionProperty(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, LPCWSTR pszProperty, ULONG cbValue, PUCHAR pbValue);
void * memmem(const void *big, int big_len, const void *little, int little_len);
BOOL IsProcessorFeaturePresent(DWORD ProcessorFeature);
BOOL ImageList_Copy(HIMAGELIST himlDst, int iDst, HIMAGELIST himlSrc, int iSrc, UINT uFlags);
struct lconv * localeconv();
HRESULT CoRegisterInitializeSpy(unknown_t *pSpy, ULARGE_INTEGER *puliCookie);
BOOL QueryThreadpoolStackInformation(PTP_POOL ptpp, PTP_POOL_STACK_INFORMATION ptpsi);
int wctomb(char *s, wchar_t wchar);
int __WSAFDIsSet(SOCKET fd, fd_set *ARG_1);
LONG RegQueryReflectionKey(HKEY hBase, BOOL *bIsReflectionDisabled);
NTSTATUS BCryptCreateHash(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_HASH_HANDLE *phHash, PUCHAR pbHashObject, ULONG cbHashObject, PUCHAR pbSecret, ULONG cbSecret, ULONG dwFlags);
size_t mbsrtowcs(wchar_t *dst, const char **src, size_t len, mbstate_t *ps);
CONFIGRET CM_Run_Detection_Ex(ULONG ulFlags, HMACHINE hMachine);
BOOL SetColorAdjustment(HDC hdc, unknown_t *lpca);
BOOL UnregisterWait(HANDLE WaitHandle);
int SHRegGetIntW(HKEY hk, PCWSTR pwzKey, int iDefault);
HRESULT VarDateFromUI8(ULONG64 ui64In, unknown_t *pdateOut);
PEXCEPTION_ROUTINE RtlVirtualUnwind(ULONG HandlerType, ULONG_PTR ImageBase, ULONG_PTR ControlPc, PRUNTIME_FUNCTION FunctionEntry, PCONTEXT ContextRecord, PVOID *HandlerData, PULONG_PTR EstablisherFrame, PKNONVOLATILE_CONTEXT_POINTERS ContextPointers);
HRESULT VarDateFromUI4(ULONG ulIn, unknown_t *pdateOut);
UINT GetSystemWow64DirectoryW(LPWSTR lpBuffer, UINT uSize);
CONFIGRET CM_Next_Range(unknown_t preElement, PDWORDLONG pullStart, PDWORDLONG pullEnd, ULONG ulFlags);
HRESULT VarDateFromUI2(USHORT uiIn, unknown_t *pdateOut);
void SysFreeString(BSTR bstrString);
VOID SubmitThreadpoolWork(PTP_WORK pwk);
long double exp2l(long double x);
DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount);
HRESULT VarDateFromUI1(BYTE bIn, unknown_t *pdateOut);
BOOL GetServiceKeyNameW(SC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, LPDWORD lpcchBuffer);
DWORD GetDeviceDriverBaseNameA(LPVOID ImageBase, LPSTR lpFilename, DWORD nSize);
float exp2f(float x);
int connect(SOCKET s, struct sockaddr *name, int namelen);
int WSASendMsg(SOCKET Handle, LPWSAMSG lpMsg, DWORD dwFlags, LPDWORD lpNumberOfBytesSent, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
HRESULT CoCreateFreeThreadedMarshaler(LPUNKNOWN punkOuter, LPUNKNOWN *ppunkMarshal);
HWND WindowFromPoint(POINT Point);
BOOL RemoveMenu(HMENU hMenu, UINT uPosition, UINT uFlags);
UINT GetSystemWow64DirectoryA(LPSTR lpBuffer, UINT uSize);
void AVIFileInit();
BOOL FlsFree(DWORD dwFlsIndex);
BOOL SetProcessDefaultLayout(DWORD dwDefaultLayout);
int WSCEnumProtocols(LPINT lpiProtocols, LPWSAPROTOCOL_INFOW lpProtocolBuffer, LPDWORD lpdwBufferLength, LPINT lpErrno);
DWORD GetDeviceDriverBaseNameW(LPVOID ImageBase, LPWSTR lpBaseName, DWORD nSize);
BOOL SymRegisterCallback64(HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, ULONG64 UserContext);
NTSTATUS BCryptResolveProviders(LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, LPCWSTR pszProvider, ULONG dwMode, ULONG dwFlags, ULONG *pcbBuffer, unknown_t *ppBuffer);
HRESULT CreatePointerMoniker(LPUNKNOWN punk, unknown_t *ppmk);
HRESULT VarUI4FromDate(unknown_t dateIn, ULONG *pulOut);
ATOM GlobalAddAtomExA(LPCSTR lpString, DWORD Flags);
BOOL SkipPointerFrameMessages(UINT32 pointerId);
BOOL SetEndOfFile(HANDLE hFile);
BOOL UserHandleGrantAccess(HANDLE hUserHandle, HANDLE hJob, BOOL bGrant);
DWORD GetTabbedTextExtentA(HDC hdc, LPCSTR lpString, int chCount, int nTabPositions, INT *lpnTabStopPositions);
BOOL GetNumaAvailableMemoryNodeEx(USHORT Node, PULONGLONG AvailableBytes);
LSTATUS SHRegOpenUSKeyA(LPCSTR pszPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU);
BOOL GetServiceKeyNameA(SC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPDWORD lpcchBuffer);
CONFIGRET CM_Add_Empty_Log_Conf_Ex(unknown_t plcLogConf, DEVINST dnDevInst, unknown_t Priority, ULONG ulFlags, HMACHINE hMachine);
HRESULT SHCreateAssociationRegistration(REFIID riid, void **ppv);
BOOL CreateDirectoryExW(LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
struct berval ** ldap_get_values_lenA(LDAP *ExternalHandle, LDAPMessage *Message, const PSTR attr);
NTSTATUS RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PCUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString);
int setenv(const char *name, const char *value, int overwrite);
BOOL InheritWindowMonitor(HWND hwnd, HWND hwndInherit);
ATOM GlobalAddAtomExW(LPCWSTR lpString, DWORD Flags);
BOOL CryptInstallDefaultContext(HCRYPTPROV hCryptProv, DWORD dwDefaultType, const void *pvDefaultPara, DWORD dwFlags, void *pvReserved, HCRYPTDEFAULTCONTEXT *phDefaultContext);
DWORD GetTabbedTextExtentW(HDC hdc, LPCWSTR lpString, int chCount, int nTabPositions, INT *lpnTabStopPositions);
BOOL SymGetSymPrev(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol);
BOOL InitOnceExecuteOnce(PINIT_ONCE InitOnce, PINIT_ONCE_FN InitFn, PVOID Parameter, LPVOID *Context);
DWORD SetLayout(HDC hdc, DWORD dwLayout);
LSTATUS SHRegOpenUSKeyW(LPCWSTR pwzPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, BOOL fIgnoreHKCU);
LPVOID MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap);
PCHAR ldap_get_dnA(LDAP *ld, LDAPMessage *entry);
BOOL K32EnumDeviceDrivers(LPVOID *lpImageBase, DWORD cb, LPDWORD lpcbNeeded);
HRESULT VarBoolFromDisp(unknown_t *pdispIn, LCID lcid, unknown_t *pboolOut);
char * strrchr(const char *s, int c);
BOOL CreateDirectoryExA(LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
struct berval ** ldap_get_values_lenW(LDAP *ExternalHandle, LDAPMessage *Message, PWSTR attr);
BOOL CancelIo(HANDLE hFile);
BOOL WinHttpTimeFromSystemTime(SYSTEMTIME *pst, LPWSTR pwszTime);
BOOL AddClipboardFormatListener(HWND hwnd);
BOOL DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent);
BOOL InvertRgn(HDC hdc, HRGN HRGN);
BOOL GetInputState();
BOOL GetClassInfoW(HINSTANCE hInstance, LPCWSTR lpClassName, LPWNDCLASSW lpWndClass);
BOOL EnumWindows(unknown_t lpEnumFunc, LPARAM lParam);
DWORD SymSetOptions(DWORD SymOptions);
BOOL CM_Is_Version_Available_Ex(WORD wVersion, HMACHINE hMachine);
int vscanf(const char *format, va_list ap);
VOID MapGenericMask(PDWORD AccessMask, PGENERIC_MAPPING GenericMapping);
BOOL ImpersonateNamedPipeClient(HANDLE hNamedPipe);
PWCHAR ldap_get_dnW(LDAP *ld, LDAPMessage *entry);
HRESULT VariantCopy(unknown_t *pvargDest, unknown_t *pvargSrc);
VOID FreeAddrInfoW(unknown_t pAddrInfo);
int fputs(const char *s, FILE *stream);
BOOL GetClassInfoA(HINSTANCE hInstance, LPCSTR lpClassName, LPWNDCLASSA lpWndClass);
BOOL SetWindowFeedbackSetting(HWND hwnd, FEEDBACK_TYPE feedback, DWORD dwFlags, UINT32 size, VOID *configuration);
BOOL CryptUnregisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID);
BOOL AccessCheckByTypeAndAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose);
BOOL FreeLibrary(HMODULE hLibModule);
DWORD PowerSetActiveScheme(HKEY UserRootPowerKey, GUID *SchemeGuid);
BOOL SetDisplayAutoRotationPreferences(ORIENTATION_PREFERENCE orientation);
BOOL AddResourceAttributeAce(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid, PCLAIM_SECURITY_ATTRIBUTES_INFORMATION pAttributeInfo, PDWORD pReturnLength);
int fputc(int c, FILE *stream);
BOOL AccessCheckByTypeAndAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose);
BOOL DeleteDC();
BOOL WinHttpGetDefaultProxyConfiguration(unknown_t *pProxyInfo);
CONFIGRET CM_Get_Device_ID_List_Size_ExW(PULONG pulLen, PCWSTR pszFilter, ULONG ulFlags, HMACHINE hMachine);
int rand();
BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount);
BOOL ImageList_Draw(HIMAGELIST himl, int i, HDC hdcDst, int x, int y, UINT fStyle);
BOOL SymGetSourceFileChecksum(HANDLE hProcess, ULONG64 Base, PCSTR FileSpec, DWORD *pCheckSumType, BYTE *pChecksum, DWORD checksumSize, DWORD *pActualBytesWritten);
BOOL StartDocPrinterA(HPRINTER hPrinter, int Level, unknown_t pDocInfo);
int GetLocaleInfoEx(LPCWSTR lpLocaleName, LCTYPE LCType, LPWSTR lpLCData, int cchData);
int vwscanf(wchar_t *format, va_list arg);
BOOL MakeSureDirectoryPathExists(PCSTR DirPath);
CONFIGRET CM_Get_Device_ID_List_Size_ExA(PULONG pulLen, PCSTR pszFilter, ULONG ulFlags, HMACHINE hMachine);
BOOL GetCPInfo(UINT CodePage, LPCPINFO lpCPInfo);
long SetStretchBltMode(HDC hdc, unknown_t iStretchMode);
BOOL AssocIsDangerous(PCWSTR pszAssoc);
LDAP * ldap_init(PSTR HostName, ULONG PortNumber);
LPVOID GlobalLock(HGLOBAL hMem);
long double nexttowardl(long double x, long double y);
BOOL StartDocPrinterW(HPRINTER hPrinter, int Level, unknown_t pDocInfo);
HANDLE CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
INT DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime, DOUBLE *pvtime);
DWORD GetFileVersionInfoSizeExW(DWORD dwFlags, LPCWSTR lpwstrFilename, LPDWORD lpdwHandle);
VOID QueryUnbiasedInterruptTimePrecise(PULONGLONG lpUnbiasedInterruptTimePrecise);
void PathRemoveExtensionW(LPWSTR pszPath);
void __error(int status, int errname, char *format);
float logbf(float x);
INT WSAInstallServiceClassW(LPWSASERVICECLASSINFOW lpServiceClassInfo);
ULONG EventAccessRemove(LPGUID Guid);
float nexttowardf(float x, long double y);
BOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, LPDWORD lpdwAbsoluteSecurityDescriptorSize, PACL pDacl, LPDWORD lpdwDaclSize, PACL pSacl, LPDWORD lpdwSaclSize, PSID pOwner, LPDWORD lpdwOwnerSize, PSID pPrimaryGroup, LPDWORD lpdwPrimaryGroupSize);
HANDLE CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
DWORD GetFileVersionInfoSizeExA(DWORD dwFlags, LPCSTR lpwstrFilename, LPDWORD lpdwHandle);
long double logbl(long double x);
HRESULT EncodeRemotePointer(HANDLE ProcessHandle, PVOID Ptr, PVOID *EncodedPtr);
INT WSAInstallServiceClassA(LPWSASERVICECLASSINFOA lpServiceClassInfo);
unknown_t * getservbyname(const char *name, const char *proto);
HRESULT SafeArrayAllocDescriptor(UINT cDims, unknown_t **ppsaOut);
BOOL GetOldestEventLogRecord(HANDLE hEventLog, PDWORD OldestRecord);
HRESULT SHCreateStreamOnFileA(LPCSTR pszFile, DWORD grfMode, struct IStream **ppstm);
void PathRemoveExtensionA(LPSTR pszPath);
BOOL SymGetSymFromAddr64(HANDLE hProcess, DWORD64 qwAddr, PDWORD64 pdwDisplacement, PIMAGEHLP_SYMBOL64 Symbol);
BOOL HeapQueryInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength, PSIZE_T ReturnLength);
HIMAGELIST ImageList_Create(int cx, int cy, UINT flags, int cInitial, int cGrow);
HRESULT VarI2FromR8(DOUBLE dblIn, SHORT *psOut);
FARPROC WSASetBlockingHook(FARPROC lpBlockFunc);
BOOL IsValidLanguageGroup(LGRPID LanguageGroup, DWORD dwFlags);
HRESULT PathCchRenameExtension(PWSTR pszPath, size_t cchPath, PCWSTR pszExt);
HWND RealChildWindowFromPoint(HWND hwndParent, POINT ptParentClientCoords);
BOOL PathStripToRootW(LPWSTR pszPath);
BOOL SetDllDirectoryA(LPCSTR lpPathName);
HRESULT VarI2FromR4(FLOAT fltIn, SHORT *psOut);
BOOL CopyFileTransactedA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags, HANDLE hTransaction);
struct berval ** ldap_get_values_len(LDAP *ExternalHandle, LDAPMessage *Message, const PSTR attr);
INT getaddrinfo(PCSTR pNodeName, PCSTR pServiceName, unknown_t *pHints, unknown_t *ppResult);
HLOCAL LocalFree(HLOCAL hMem);
BOOL PathStripToRootA(LPSTR pszPath);
HRESULT PathCchRemoveBackslashEx(PWSTR pszPath, size_t cchPath, PWSTR *ppszEnd, size_t *pcchRemaining);
ULONG ldap_escape_filter_element(PCHAR sourceFilterElement, ULONG sourceLength, PCHAR destFilterElement, ULONG destLength);
HRESULT SHCreateStreamOnFileW(LPCWSTR pszFile, DWORD grfMode, struct IStream **ppstm);
HANDLE CreateFile2(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwCreationDisposition, LPCREATEFILE2_EXTENDED_PARAMETERS pCreateExParams);
BOOL ProcessIdToSessionId(DWORD dwProcessId, DWORD *pSessionId);
BOOL SymFromIndexW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, PSYMBOL_INFOW Symbol);
HRESULT VarR8FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, DOUBLE *pdblOut);
HRESULT SafeArrayUnlock(unknown_t *psa);
BOOL SetDllDirectoryW(LPCWSTR lpPathName);
BOOL CopyFileTransactedW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, LPBOOL pbCancel, DWORD dwCopyFlags, HANDLE hTransaction);
SECURITY_STATUS NCryptDeriveKey(NCRYPT_SECRET_HANDLE hSharedSecret, LPCWSTR pwszKDF, unknown_t *pParameterList, PBYTE pbDerivedKey, DWORD cbDerivedKey, DWORD *pcbResult, ULONG dwFlags);
PWSTR SymSetHomeDirectoryW(HANDLE hProcess, PCWSTR dir);
DWORD CredUIStoreSSOCredW(PCWSTR pszRealm, PCWSTR pszUsername, PCWSTR pszPassword, BOOL bPersist);
LSTATUS SHGetValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD *pdwType, void *pvData, DWORD *pcbData);
BOOL IsCharLowerA(CHAR ch);
int GetWindowTextA(HWND hWnd, LPSTR lpString, int nMaxCount);
BOOL PathIsURLW(LPCWSTR pszPath);
WORD CM_Get_Version();
BOOL LineTo(HDC hdc, int nXEnd, int nYEnd);
int CompareStringOrdinal(LPCWCH lpString1, int cchCount1, LPCWCH lpString2, int cchCount2, BOOL bIgnoreCase);
DWORD VerInstallFileA(DWORD uFlags, LPCSTR szSrcFileName, LPCSTR szDestFileName, LPCSTR szSrcDir, LPCSTR szDestDir, LPCSTR szCurDir, LPSTR szTmpFile, PUINT puTmpFileLen);
HRESULT CreateProfile(LPCWSTR pszUserSid, LPCWSTR pszUserName, LPWSTR pszProfilePath, DWORD cchProfilePath);
float atanhf(float x);
BOOL GetSystemPreferredUILanguages(DWORD dwFlags, PULONG pulNumLanguages, PZZWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer);
BOOL Ellipse(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
BOOL PathIsURLA(LPCSTR pszPath);
BOOL IsCharLowerW(WCHAR ch);
int WSPStartup(WORD wVersionRequested, LPWSPDATA lpWSPData, LPWSAPROTOCOL_INFOW lpProtocolInfo, unknown_t UpcallTable, LPWSPPROC_TABLE lpProcTable);
BOOL IsTouchWindow(HWND hwnd, PULONG pulFlags);
PSTR StrFormatByteSize64A(LONGLONG qdw, PSTR pszBuf, UINT cchBuf);
LSTATUS SHGetValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD *pdwType, void *pvData, DWORD *pcbData);
int GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount);
HANDLE OpenPrivateNamespaceW(LPVOID lpBoundaryDescriptor, LPCWSTR lpAliasPrefix);
ULONG ldap_delete_sW(LDAP *ld, PWSTR dn);
long double atanhl(long double x);
LONG GetBitmapBits(HBITMAP hbmp, LONG cbBuffer, LPVOID lpvBits);
DWORD SymGetOptions();
DWORD WinHttpGetProxyForUrlEx2(HINTERNET hResolver, PCWSTR pcwszUrl, unknown_t *pAutoProxyOptions, DWORD cbInterfaceSelectionContext, BYTE *pInterfaceSelectionContext, DWORD_PTR pContext);
DWORD VerInstallFileW(DWORD uFlags, LPCWSTR szSrcFileName, LPCWSTR szDestFileName, LPCWSTR szSrcDir, LPCWSTR szDestDir, LPCWSTR szCurDir, LPWSTR szTmpFile, PUINT puTmpFileLen);
BOOL SymGetLineFromAddr(HANDLE hProcess, DWORD dwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINE Line);
BOOL CreateProcessWithTokenW(HANDLE hToken, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
VOID WinHttpFreeProxySettings(unknown_t *pWinHttpProxySettings);
BOOL IsCharSpaceA(CHAR wch);
BOOL SymGetSourceVarFromTokenW(HANDLE hProcess, PVOID Token, PCWSTR Params, PCWSTR VarName, PWSTR Value, DWORD Size);
BOOL GetProcessShutdownParameters(LPDWORD lpdwLevel, LPDWORD lpdwFlags);
DWORD QueryDosDeviceA(LPCSTR lpDeviceName, LPSTR lpTargetPath, DWORD ucchMax);
HANDLE OpenPrivateNamespaceA(LPVOID lpBoundaryDescriptor, LPCSTR lpAliasPrefix);
ULONG ldap_delete_sA(LDAP *ld, const PSTR dn);
CONFIGRET CM_Get_DevNode_Custom_Property_ExW(DEVINST dnDevInst, PCWSTR pszCustomPropertyName, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL SHSkipJunction(unknown_t *pbc, unknown_t *pclsid);
BOOL WaitForDebugEventEx(unknown_t lpDebugEvent, DWORD dwMilliseconds);
HRESULT GetIDsOfNames(REFIID riid, unknown_t *rgszNames, UINT cNames, LCID lcid, unknown_t *rgDispId);
bool isnormal(double x);
DWORD QueryDosDeviceW(LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax);
BOOL IsCharSpaceW(WCHAR wch);
HRESULT SafeArrayPutElement(unknown_t *psa, LONG *rgIndices, void *pv);
BOOL InitializeFlatSB(HWND ARG_0);
DWORD GetLogicalDrives();
UINT MapVirtualKeyExW(UINT uCode, UINT uMapType, HKL dwhkl);
BOOL OpenIcon(HWND hWnd);
ULONG EventWriteString(REGHANDLE RegHandle, UCHAR Level, ULONGLONG Keyword, PCWSTR String);
CONFIGRET CM_Delete_Range(DWORDLONG ullStartValue, DWORDLONG ullEndValue, unknown_t rlh, ULONG ulFlags);
HANDLE FindExecutableImageExW(PCWSTR FileName, PCWSTR SymbolPath, PWSTR ImageFilePath, PFIND_EXE_FILE_CALLBACKW Callback, PVOID CallerData);
SECURITY_STATUS NCryptVerifySignature(NCRYPT_KEY_HANDLE hKey, VOID *pPaddingInfo, PBYTE pbHashValue, DWORD cbHashValue, PBYTE pbSignature, DWORD cbSignature, DWORD dwFlags);
CONFIGRET CM_Get_DevNode_Custom_Property_ExA(DEVINST dnDevInst, PCSTR pszCustomPropertyName, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
CONFIGRET CM_Reenumerate_DevNode(DEVINST dnDevInst, ULONG ulFlags);
NTSTATUS BCryptFinalizeKeyPair(BCRYPT_KEY_HANDLE hKey, ULONG dwFlags);
HRESULT StrRetToBSTR(unknown_t *pstr, unknown_t pidl, BSTR *pbstr);
DWORD WTSGetServiceSessionId();
ULONG ldap_modrdn2A(LDAP *ExternalHandle, const PSTR DistinguishedName, const PSTR NewDistinguishedName, INT DeleteOldRdn);
WORD TileWindows(HWND hwndParent, UINT wHow, RECT *lpRect, UINT cKids, HWND *lpKids);
UINT MapVirtualKeyExA(UINT uCode, UINT uMapType, HKL dwhkl);
CONFIGRET CM_Get_DevNode_Property_ExW(DEVINST dnDevInst, unknown_t *PropertyKey, unknown_t *PropertyType, PBYTE PropertyBuffer, PULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine);
LPVOID HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes);
int sscanf(const char *s, const char *format, va_list args);
ULONG ldap_modrdn2W(LDAP *ExternalHandle, PWSTR DistinguishedName, PWSTR NewDistinguishedName, INT DeleteOldRdn);
BOOL AngleArc(HDC hdc, int X, int Y, DWORD dwRadius, FLOAT eStartAngle, FLOAT eSweepAngle);
LONG SetDisplayConfig(UINT32 numPathArrayElements, unknown_t *pathArray, UINT32 numModeInfoArrayElements, unknown_t *modeInfoArray, UINT32 flags);
HRESULT CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID iid, LPVOID *ppv);
BOOL SymEnumTypesByName(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR mask, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext);
BOOL K32GetPerformanceInfo(PPERFORMANCE_INFORMATION pPerformanceInformation, DWORD cb);
int lstrcmpiA(LPCSTR lpString1, LPCSTR lpString2);
PCCTL_CONTEXT CertEnumCTLsInStore(HCERTSTORE hCertStore, PCCTL_CONTEXT pPrevCtlContext);
HRESULT SHLoadIndirectString(PCWSTR pszSource, PWSTR pszOutBuf, UINT cchOutBuf, void **ppvReserved);
CONFIGRET CM_Request_Eject_PC();
PDWORD GetSidSubAuthority(PSID pSid, DWORD nSubAuthority);
LPWSTR CharNextW(LPCWSTR lpsz);
BOOL CertGetStoreProperty(HCERTSTORE hCertStore, DWORD dwPropId, void *pvData, DWORD *pcbData);
BOOL WaitMessage();
PCCERT_CONTEXT CertDuplicateCertificateContext(PCCERT_CONTEXT pCertContext);
SHORT VkKeyScanExA(CHAR ch, HKL dwhkl);
size_t strxfrm(char *s1, const char *s2, size_t n);
HRESULT SHGetNameFromIDList(unknown_t pidl, unknown_t sigdnName, PWSTR *ppszName);
HRESULT VarUI4FromUI2(USHORT uiIn, ULONG *pulOut);
BOOL TransparentBlt(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int hHeightDest, HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, UINT crTransparent);
int lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2);
BOOL SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes);
BOOL IsOS(DWORD dwOS);
BOOL DeleteEnclave(LPVOID lpAddress);
HRESULT VarUI4FromUI1(BYTE bIn, ULONG *pulOut);
UINT GetTempFileNameW(LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName);
BOOL InitializeProcessForWsWatch(HANDLE hProcess);
HWND GetForegroundWindow();
HRESULT SHRemoveLocalizedName(PCWSTR pszPath);
NTSTATUS NtQueryMultipleValueKey(HANDLE KeyHandle, PKEY_VALUE_ENTRY ValueEntries, ULONG EntryCount, PVOID ValueBuffer, PULONG BufferLength, PULONG RequiredBufferLength);
LRESULT DefMDIChildProcA(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
HRESULT VarUI4FromUI8(ULONG64 ui64In, ULONG *plOut);
BOOL SetThreadIdealProcessorEx(HANDLE hThread, PPROCESSOR_NUMBER lpIdealProcessor, PPROCESSOR_NUMBER lpPreviousIdealProcessor);
CONFIGRET CM_Get_Log_Conf_Priority_Ex(unknown_t lcLogConf, unknown_t pPriority, ULONG ulFlags, HMACHINE hMachine);
LPSTR CharNextA(LPCSTR lpsz);
BOOL SetFileAttributesW(LPCWSTR lpFileName, DWORD dwFileAttributes);
HANDLE GetPropA(HWND hWnd, LPCSTR lpString);
SHORT VkKeyScanExW(WCHAR ch, HKL dwhkl);
LPCSTR PathFindSuffixArrayA(LPCSTR pszPath, LPCSTR *apszSuffix, int iArraySize);
BOOL SymAddSymbolW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Name, DWORD64 Address, DWORD Size, DWORD Flags);
BOOL FlushPrinter(HPRINTER hPrinter, LPVOID pBuf, int cbBuf, LPDWORD pcWritten, DWORD cSleep);
INT WSAProviderConfigChange(LPHANDLE lpNotificationHandle, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
HRESULT GetNaturalExtent(DWORD dwAspect, LONG lindex, unknown_t *ptd, HDC hicTargetDev, unknown_t *pExtentInfo, unknown_t pSizel);
LRESULT DefMDIChildProcW(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL AddFormW(HPRINTER hPrinter, int Level, LPBYTE pForm);
HANDLE GetPropW(HWND hWnd, LPCWSTR lpString);
UINT GetTempFileNameA(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName);
BOOL GetCommTimeouts(HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts);
int ImageList_GetImageCount(HIMAGELIST himl);
LPCWSTR PathFindSuffixArrayW(LPCWSTR pszPath, LPCWSTR *apszSuffix, int iArraySize);
int ScrollWindowEx(HWND hWnd, int dx, int dy, RECT *prcScroll, RECT *prcClip, HRGN hrgnUpdate, LPRECT prcUpdate, UINT flags);
BOOL ClipCursor(RECT *lpRect);
BOOL AddFormA(HPRINTER hPrinter, int Level, LPBYTE pForm);
BOOL SymSearchW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, DWORD SymTag, PCWSTR Mask, DWORD64 Address, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext, DWORD Options);
BOOL FindNextVolumeA(HANDLE hFindVolume, LPSTR lpszVolumeName, DWORD cchBufferLength);
int GetUpdateRgn(HWND hWnd, HRGN hRgn, BOOL bErase);
ULONG RemoveVectoredExceptionHandler(PVOID Handle);
LONG CveEventWrite(PCWSTR CveId, PCWSTR AdditionalDetails);
size_t mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps);
BOOL UnregisterPowerSettingNotification(HPOWERNOTIFY Handle);
BOOL CertRetrieveLogoOrBiometricInfo(PCCERT_CONTEXT pCertContext, LPCSTR lpszLogoOrBiometricType, DWORD dwRetrievalFlags, DWORD dwTimeout, DWORD dwFlags, void *pvReserved, BYTE **ppbData, DWORD *pcbData, LPWSTR *ppwszMimeType);
DWORD GetTickCount();
PWSTR SymGetHomeDirectoryW(DWORD type, PWSTR dir, size_t size);
BOOL FindNextVolumeW(HANDLE hFindVolume, LPWSTR lpszVolumeName, DWORD cchBufferLength);
int WSARecvDisconnect(SOCKET s, LPWSABUF lpInboundDisconnectData);
UINT SendInput(UINT cInputs, LPINPUT pInputs, int cbSize);
HWND GetParent(HWND hWnd);
int vswprintf(wchar_t *s, size_t n, wchar_t *format, va_list arg);
BOOL FreePrinterNotifyInfo();
long SaveDC();
PVOID RtlPcToFileHeader(PVOID PcValue, PVOID *BaseOfImage);
ULONG QueryAllTracesW(PEVENT_TRACE_PROPERTIES *PropertyArray, ULONG PropertyArrayCount, PULONG LoggerCount);
BOOL SymCleanup(HANDLE hProcess);
int ioctlsocket(SOCKET s, long cmd, u_long *argp);
CONFIGRET CM_Register_Notification(unknown_t pFilter, PVOID pContext, unknown_t pCallback, unknown_t pNotifyContext);
double fdim(double x, double y);
int LookupIconIdFromDirectoryEx(PBYTE presbits, BOOL fIcon, int cxDesired, int cyDesired, UINT Flags);
BOOL CertGetEnhancedKeyUsage(PCCERT_CONTEXT pCertContext, DWORD dwFlags, PCERT_ENHKEY_USAGE pUsage, DWORD *pcbUsage);
HRESULT StrRetToStrW(unknown_t *pstr, unknown_t pidl, LPWSTR *ppsz);
int GetMenuStringW(HMENU hMenu, UINT uIDItem, LPWSTR lpString, int cchMax, UINT flags);
HWND WindowFromPhysicalPoint(POINT Point);
ULONG ldap_add(LDAP *ld, PSTR dn, unknown_t **attrs);
VOID CredFree(PVOID Buffer);
LONG CertVerifyTimeValidity(LPFILETIME pTimeToVerify, PCERT_INFO pCertInfo);
ULONG QueryAllTracesA(PEVENT_TRACE_PROPERTIES *PropertyArray, ULONG PropertyArrayCount, PULONG LoggerCount);
NTSTATUS BCryptExportKey(BCRYPT_KEY_HANDLE hKey, BCRYPT_KEY_HANDLE hExportKey, LPCWSTR pszBlobType, PUCHAR pbOutput, ULONG cbOutput, ULONG *pcbResult, ULONG dwFlags);
LPCWSTR CryptFindLocalizedName(LPCWSTR pwszCryptName);
ATOM RegisterClassA(unknown_t *lpWndClass);
BOOL CreateRestrictedToken(HANDLE ExistingTokenHandle, DWORD Flags, DWORD DisableSidCount, PSID_AND_ATTRIBUTES SidsToDisable, DWORD DeletePrivilegeCount, PLUID_AND_ATTRIBUTES PrivilegesToDelete, DWORD RestrictedSidCount, PSID_AND_ATTRIBUTES SidsToRestrict, PHANDLE NewTokenHandle);
BOOL AreDpiAwarenessContextsEqual(DPI_AWARENESS_CONTEXT dpiContextA, DPI_AWARENESS_CONTEXT dpiContextB);
HRESULT CreateTypeLib(unknown_t syskind, LPCOLESTR szFile, unknown_t **ppctlib);
HRESULT StrRetToStrA(unknown_t *pstr, unknown_t pidl, LPSTR *ppsz);
int GetMenuStringA(HMENU hMenu, UINT uIDItem, LPSTR lpString, int cchMax, UINT flags);
HRESULT SafeArrayRedim(unknown_t *psa, unknown_t *psaboundNew);
UINT SysStringByteLen(BSTR bstr);
ULONG ldap_count_values(PCHAR *vals);
BOOL DebugBreakProcess(HANDLE Process);
ULONG ldap_ufn2dnA(const PSTR ufn, PSTR *pDn);
ATOM RegisterClassW(unknown_t *lpWndClass);
BOOL SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Name, PSYMBOL_INFO Symbol);
ULONG ldap_bind_s(LDAP *ld, const PSTR dn, PCHAR cred, ULONG method);
BOOL SymEnumSymbolsForAddrW(HANDLE hProcess, DWORD64 Address, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
BOOL AddPrinterDriverExA(LPSTR pName, int Level, LPBYTE pDriverInfo, unknown_t dwFileCopyFlags);
ULONG ldap_ufn2dnW(PWSTR ufn, PWSTR *pDn);
HRESULT VarR8FromDate(unknown_t dateIn, DOUBLE *pdblOut);
UINT IsDlgButtonChecked(HWND hDlg, int nIDButton);
VOID SetThreadpoolTimer(PTP_TIMER pti, PFILETIME pftDueTime, DWORD msPeriod, DWORD msWindowLength);
PVOID MapViewOfFileFromApp(HANDLE hFileMappingObject, ULONG DesiredAccess, ULONG64 FileOffset, SIZE_T NumberOfBytesToMap);
int WSCInstallProvider64_32(LPGUID lpProviderId, WCHAR *lpszProviderDllPath, const LPWSAPROTOCOL_INFOW lpProtocolInfoList, DWORD dwNumberOfEntries, LPINT lpErrno);
time_t mktime(struct tm *timeptr);
BOOL CryptHashMessage(PCRYPT_HASH_MESSAGE_PARA pHashPara, BOOL fDetachedHash, DWORD cToBeHashed, BYTE **rgpbToBeHashed, DWORD *rgcbToBeHashed, BYTE *pbHashedBlob, DWORD *pcbHashedBlob, BYTE *pbComputedHash, DWORD *pcbComputedHash);
HRGN CreateRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
void * objc_msgSendSuper2(void *instance, char *selector);
HRESULT VarUI2FromDate(unknown_t dateIn, USHORT *puiOut);
NTSTATUS RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PCANSI_STRING SourceString, BOOLEAN AllocateDestinationString);
BOOL PlayMetaFileRecord(HDC hdc, unknown_t lpHandletable, unknown_t lpMetaRecord, UINT nHandles);
int PathCommonPrefixW(LPCWSTR pszFile1, LPCWSTR pszFile2, LPWSTR achPath);
BOOL InitAtomTable(DWORD nSize);
BOOL AddPrinterDriverExW(LPWSTR pName, int Level, LPBYTE pDriverInfo, unknown_t dwFileCopyFlags);
INT GetAddrInfoW(PCWSTR pNodeName, PCWSTR pServiceName, unknown_t *pHints, unknown_t *ppResult);
BOOL SetFileAttributesTransactedA(LPCSTR lpFileName, DWORD dwFileAttributes, HANDLE hTransaction);
BOOL SetThreadpoolTimerEx(PTP_TIMER pti, PFILETIME pftDueTime, DWORD msPeriod, DWORD msWindowLength);
PUMS_CONTEXT GetNextUmsListItem(PUMS_CONTEXT UmsContext);
HKL GetKeyboardLayout(DWORD idThread);
PCSTR SymSrvStoreSupplement(HANDLE hProcess, PCSTR SrvPath, PCSTR Node, PCSTR File, DWORD Flags);
char * strcat(char *s1, const char *s2);
PSLIST_ENTRY InterlockedPushListSListEx(PSLIST_HEADER ListHead, PSLIST_ENTRY List, PSLIST_ENTRY ListEnd, ULONG Count);
DWORD CharUpperBuffA(LPSTR lpsz, DWORD cchLength);
int PathCommonPrefixA(LPCSTR pszFile1, LPCSTR pszFile2, LPSTR achPath);
bool isnan(double x);
BOOL SymMatchString(PCSTR string, PCSTR expression, BOOL fCase);
ULONG ldap_abandon(LDAP *ld, ULONG msgid);
BOOL SetFileAttributesTransactedW(LPCWSTR lpFileName, DWORD dwFileAttributes, HANDLE hTransaction);
INT WSAProviderCompleteAsyncCall(HANDLE hAsyncCall, INT iRetCode);
DWORD ReadThreadProfilingData(HANDLE PerformanceDataHandle, DWORD Flags, PPERFORMANCE_DATA PerformanceData);
LPSTR PathRemoveBackslashA(LPSTR pszPath);
PVOID ImageDirectoryEntryToDataEx(PVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size, PIMAGE_SECTION_HEADER *FoundHeader);
imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
VOID WakeAllConditionVariable(PCONDITION_VARIABLE ConditionVariable);
BOOL EnableMouseInPointer(BOOL fEnable);
void CoFreeLibrary(HINSTANCE hInst);
HWND ChildWindowFromPointEx(HWND hwnd, POINT pt, UINT flags);
DWORD K32GetDeviceDriverBaseNameA(LPVOID ImageBase, LPSTR lpFilename, DWORD nSize);
DWORD DragObject(HWND hwndParent, HWND hwndFrom, UINT fmt, ULONG_PTR data, HCURSOR hcur);
BOOL SetComputerNameExW(COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer);
DWORD CoGetCurrentProcess();
DWORD GetTapeStatus(HANDLE hDevice);
VOID CloseThreadpoolTimer(PTP_TIMER pti);
LSTATUS RegSaveKeyExW(HKEY hKey, LPCWSTR lpFile, const LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD Flags);
DWORD CharUpperBuffW(LPWSTR lpsz, DWORD cchLength);
BOOL GetAltTabInfoW(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText);
HGLOBAL GlobalFree(HGLOBAL hMem);
size_t wcslen(wchar_t *s);
HRESULT CoWaitForMultipleHandles(DWORD dwFlags, DWORD dwTimeout, ULONG cHandles, LPHANDLE pHandles, LPDWORD lpdwindex);
BOOL SetMenu(HWND hWnd, HMENU hMenu);
DWORD K32GetDeviceDriverBaseNameW(LPVOID ImageBase, LPWSTR lpBaseName, DWORD nSize);
BOOL WidenPath();
PCCERT_CHAIN_CONTEXT CertDuplicateCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext);
BOOL SetComputerNameExA(COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer);
LPWSTR PathRemoveBackslashW(LPWSTR pszPath);
HRESULT CoGetDefaultContext(APTTYPE aptType, REFIID riid, void **ppv);
HDC CreateCompatibleDC();
char * textdomain(char *domainname);
BOOL RegisterHotKey(HWND hWnd, int id, UINT fsModifiers, UINT vk);
HRESULT UrlFixupW(PCWSTR pcszUrl, PWSTR pszTranslatedUrl, DWORD cchMax);
LONG CompareFileTime(FILETIME *lpFileTime1, FILETIME *lpFileTime2);
BOOL GetAltTabInfoA(HWND hwnd, int iItem, PALTTABINFO pati, LPSTR pszItemText, UINT cchItemText);
clock_t clock();
LONG RegDisableReflectionKey(HKEY hBase);
int ImageList_Add(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask);
VOID SetDebugErrorLevel(DWORD dwLevel);
LSTATUS RegSaveKeyExA(HKEY hKey, LPCSTR lpFile, const LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD Flags);
BOOL ResetEvent(HANDLE hEvent);
BOOL CryptRetrieveObjectByUrlA(LPCSTR pszUrl, LPCSTR pszObjectOid, DWORD dwRetrievalFlags, DWORD dwTimeout, LPVOID *ppvObject, HCRYPTASYNC hAsyncRetrieve, PCRYPT_CREDENTIALS pCredentials, LPVOID pvVerify, PCRYPT_RETRIEVE_AUX_INFO pAuxInfo);
HCURSOR OleIconToCursor(HINSTANCE hinstExe, HICON hIcon);
BOOL UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo);
HRESULT VarDecAbs(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
BOOL GetLogColorSpaceA(HCOLORSPACE hColorSpace, unknown_t lpBuffer, DWORD nSize);
BOOL CertAddEncodedCertificateToStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, BYTE *pbCertEncoded, DWORD cbCertEncoded, DWORD dwAddDisposition, PCCERT_CONTEXT *ppCertContext);
HWND CreateToolbarEx(HWND hwnd, DWORD ws, UINT wID, int nBitmaps, HINSTANCE hBMInst, UINT_PTR wBMID, LPCTBBUTTON lpButtons, int iNumButtons, int dxButton, int dyButton, int dxBitmap, int dyBitmap, UINT uStructSize);
CONFIGRET CM_Get_DevNode_Status(PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst, ULONG ulFlags);
BOOL DeletePrinterDriverExW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pDriverName, unknown_t dwDeleteFlag, DWORD dwVersionFlag);
BOOL GetLogColorSpaceW(HCOLORSPACE hColorSpace, unknown_t lpBuffer, DWORD nSize);
int GetDurationFormat(LCID Locale, DWORD dwFlags, SYSTEMTIME *lpDuration, ULONGLONG ullDuration, LPCWSTR lpFormat, LPWSTR lpDurationStr, int cchDuration);
LPVOID CoTaskMemRealloc(LPVOID pv, SIZE_T cb);
BOOL PulseEvent(HANDLE hEvent);
UINT ExtractIconExW(LPCWSTR lpszFile, int nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIcons);
BOOL CryptRetrieveObjectByUrlW(LPCWSTR pszUrl, LPCSTR pszObjectOid, DWORD dwRetrievalFlags, DWORD dwTimeout, LPVOID *ppvObject, HCRYPTASYNC hAsyncRetrieve, PCRYPT_CREDENTIALS pCredentials, LPVOID pvVerify, PCRYPT_RETRIEVE_AUX_INFO pAuxInfo);
LCID GetSystemDefaultLCID();
int iswxdigit(wint_t wc);
HWND GetOpenClipboardWindow();
LSTATUS RegOpenKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult);
BOOL DeletePrinterDriverExA(LPSTR pName, LPSTR pEnvironment, LPSTR pDriverName, unknown_t dwDeleteFlag, DWORD dwVersionFlag);
BOOL WritePrivateProfileStringA(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName);
HRESULT CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm);
int SetTextCharacterExtra(HDC hdc, int nCharExtra);
HRESULT SHGetDataFromIDListA(unknown_t *psf, LPCITEMIDLIST pidl, unknown_t nFormat, PVOID pv, int cb);
HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName);
BOOL CertComparePublicKeyInfo(DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pPublicKey1, PCERT_PUBLIC_KEY_INFO pPublicKey2);
LSTATUS RegDeleteKeyExA(HKEY hKey, LPCSTR lpSubKey, REGSAM samDesired, DWORD Reserved);
int GetDeviceCaps(HDC hdc, unknown_t nIndex);
LSTATUS RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult);
UINT ExtractIconExA(LPCSTR lpszFile, int nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIcons);
BOOL GetPointerDeviceRects(HANDLE device, RECT *pointerDeviceRect, RECT *displayRect);
BOOL WritePrivateProfileStringW(LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName);
HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName);
SECURITY_STATUS NCryptDecrypt(NCRYPT_KEY_HANDLE hKey, PBYTE pbInput, DWORD cbInput, VOID *pPaddingInfo, PBYTE pbOutput, DWORD cbOutput, DWORD *pcbResult, DWORD dwFlags);
BOOL CryptHashSessionKey(HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags);
LSTATUS RegDeleteKeyExW(HKEY hKey, LPCWSTR lpSubKey, REGSAM samDesired, DWORD Reserved);
BOOL CryptSetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszValueName, DWORD dwValueType, BYTE *pbValueData, DWORD cbValueData);
ULONG CoReleaseServerProcess();
BOOL CertAddCertificateContextToStore(HCERTSTORE hCertStore, PCCERT_CONTEXT pCertContext, DWORD dwAddDisposition, PCCERT_CONTEXT *ppStoreContext);
HRESULT PowerRegisterForEffectivePowerModeNotifications(ULONG Version, EFFECTIVE_POWER_MODE_CALLBACK *Callback, VOID *Context, VOID **RegistrationHandle);
BOOL CertSerializeCertificateStoreElement(PCCERT_CONTEXT pCertContext, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement);
BerElement * ber_init(BERVAL *pBerVal);
HMENU LoadMenuIndirectW(unknown_t *lpMenuTemplate);
HRESULT GetColorSet(DWORD dwDrawAspect, LONG lindex, void *pvAspect, unknown_t *ptd, HDC hicTargetDev, unknown_t **ppColorSet);
HRESULT VarDecAdd(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
BOOL RestoreDC(HDC hdc, int nSavedDC);
LSTATUS SHSetValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData);
ULONG ldap_modifyW(LDAP *ld, PWSTR dn, unknown_t **mods);
HRESULT SHGetDataFromIDListW(unknown_t *psf, LPCITEMIDLIST pidl, unknown_t nFormat, PVOID pv, int cb);
PWSTR StrCpyW(PWSTR psz1, PCWSTR psz2);
HWND SetFocus(HWND hWnd);
ULONG EnumerateTraceGuidsEx(TRACE_QUERY_INFO_CLASS TraceQueryInfoClass, PVOID InBuffer, ULONG InBufferSize, PVOID OutBuffer, ULONG OutBufferSize, PULONG ReturnLength);
DWORD GetFinalPathNameByHandleA(HANDLE hFile, LPSTR lpszFilePath, DWORD cchFilePath, DWORD dwFlags);
HMONITOR MonitorFromWindow(HWND hwnd, DWORD dwFlags);
HRSRC FindResourceExW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage);
BOOL GetFileVersionInfoExW(DWORD dwFlags, LPCWSTR lpwstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
BOOL SHInvokePrinterCommandA(HWND hwnd, UINT uAction, LPCSTR lpBuf1, LPCSTR lpBuf2, BOOL fModal);
VOID GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime);
INT WSAGetServiceClassNameByClassIdW(LPGUID lpServiceClassId, LPWSTR lpszServiceClassName, LPDWORD lpdwBufferLength);
HMENU LoadMenuIndirectA(unknown_t *lpMenuTemplate);
ULONG ldap_modifyA(LDAP *ld, PSTR dn, unknown_t **mods);
BOOL GetAllUsersProfileDirectoryW(LPWSTR lpProfileDir, LPDWORD lpcchSize);
PWSTR StrStrNIW(PCWSTR pszFirst, PCWSTR pszSrch, UINT cchMax);
HRESULT SetThreadDescription(HANDLE hThread, PCWSTR lpThreadDescription);
BOOL UnregisterWaitEx(HANDLE WaitHandle, HANDLE CompletionEvent);
BOOL SHInvokePrinterCommandW(HWND hwnd, UINT uAction, LPCWSTR lpBuf1, LPCWSTR lpBuf2, BOOL fModal);
BOOL SetThreadPriority(HANDLE hThread, int nPriority);
DWORD GetFinalPathNameByHandleW(HANDLE hFile, LPWSTR lpszFilePath, DWORD cchFilePath, DWORD dwFlags);
LSTATUS SHSetValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwType, LPCVOID pvData, DWORD cbData);
HRESULT IStream_WritePidl(struct IStream *pstm, unknown_t pidlWrite);
UINT RegisterClipboardFormatA(LPCSTR lpszFormat);
INT WSAGetServiceClassNameByClassIdA(LPGUID lpServiceClassId, LPSTR lpszServiceClassName, LPDWORD lpdwBufferLength);
BOOL GetFileVersionInfoExA(DWORD dwFlags, LPCSTR lpwstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
INT SetServiceW(DWORD dwNameSpace, DWORD dwOperation, DWORD dwFlags, LPSERVICE_INFOW lpServiceInfo, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo, LPDWORD lpdwStatusFlags);
DWORD GetPaletteEntries(HPALETTE hpal, UINT iStartIndex, UINT nEntries, unknown_t lppe);
HRESULT VarNumFromParseNum(unknown_t *pnumprs, BYTE *rgbDig, ULONG dwVtBits, VARIANT *pvar);
HRESULT VarUI4FromBool(unknown_t boolIn, ULONG *pulOut);
BOOL GetAllUsersProfileDirectoryA(LPSTR lpProfileDir, LPDWORD lpcchSize);
HRSRC FindResourceExA(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage);
void SetProcessReference(IUnknown *punk);
HRESULT GetAltMonthNames(LCID lcid, LPOLESTR **prgp);
BOOL FindNextChangeNotification(HANDLE hChangeHandle);
int GetClipboardFormatNameW(UINT format, LPWSTR lpszFormatName, int cchMaxCount);
BOOL GetAppContainerAce(PACL Acl, DWORD StartingAceIndex, PVOID *AppContainerAce, DWORD *AppContainerAceIndex);
HANDLE FindFirstChangeNotificationW(LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter);
BOOL ScreenToClient(HWND hWnd, LPPOINT lpPoint);
DWORD CertGetPublicKeyLength(DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pPublicKey);
int fpclassify(double x);
int WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWCH lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCCH lpDefaultChar, LPBOOL lpUsedDefaultChar);
HRESULT VarR8FromDec(DECIMAL *pdecIn, DOUBLE *pdblOut);
ULONGLONG GetTickCount64();
INT SetServiceA(DWORD dwNameSpace, DWORD dwOperation, DWORD dwFlags, LPSERVICE_INFOA lpServiceInfo, LPSERVICE_ASYNC_INFO lpServiceAsyncInfo, LPDWORD lpdwStatusFlags);
BOOL EnumResourceLanguagesW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROCW lpEnumFunc, LONG_PTR lParam);
UINT RegisterClipboardFormatW(LPCWSTR lpszFormat);
BOOL GetWindowOrgEx(HDC hdc, LPPOINT lpPoint);
BOOL ReadConsoleOutputCharacterA(HANDLE hConsoleOutput, LPSTR lpCharacter, DWORD nLength, COORD dwReadCoord, LPDWORD lpNumberOfCharsRead);
BOOL IsWow64Process(HANDLE hProcess, PBOOL Wow64Process);
HANDLE FindFirstChangeNotificationA(LPCSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter);
BOOL CryptUnprotectData(unknown_t *pDataIn, LPWSTR *ppszDataDescr, unknown_t *pOptionalEntropy, PVOID pvReserved, unknown_t *pPromptStruct, DWORD dwFlags, unknown_t *pDataOut);
int GetClipboardFormatNameA(UINT format, LPSTR lpszFormatName, int cchMaxCount);
BOOL SymFromTokenW(HANDLE hProcess, DWORD64 Base, DWORD Token, PSYMBOL_INFOW Symbol);
int IntersectClipRect(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
HRESULT CoDisableCallCancellation(LPVOID pReserved);
LSTATUS SHRegGetUSValueW(LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD *pdwType, void *pvData, DWORD *pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, DWORD dwDefaultDataSize);
ULONG_PTR SetClassLongPtrW(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
VOID GetSystemTime(LPSYSTEMTIME lpSystemTime);
ULONG ldap_deleteW(LDAP *ld, PWSTR dn);
BOOL ReadConsoleOutputCharacterW(HANDLE hConsoleOutput, LPWSTR lpCharacter, DWORD nLength, COORD dwReadCoord, LPDWORD lpNumberOfCharsRead);
int LCIDToLocaleName(LCID Locale, LPWSTR lpName, int cchName, DWORD dwFlags);
BOOL EnumResourceLanguagesA(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROCA lpEnumFunc, LONG_PTR lParam);
LPVOID ConvertThreadToFiber(LPVOID lpParameter);
void __bzero(void *s, size_t n);
LSTATUS RegQueryMultipleValuesW(HKEY hKey, PVALENTW val_list, DWORD num_vals, LPWSTR lpValueBuf, LPDWORD ldwTotsize);
BOOL GetNumaAvailableMemoryNode(UCHAR Node, PULONGLONG AvailableBytes);
PCCERT_CONTEXT CertFindCertificateInStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, DWORD dwFindFlags, DWORD dwFindType, const void *pvFindPara, PCCERT_CONTEXT pPrevCertContext);
ULONG ldap_deleteA(LDAP *ld, const PSTR dn);
BOOL CredDeleteA(LPCSTR TargetName, DWORD Type, DWORD Flags);
LSTATUS SHRegGetUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, DWORD *pdwType, void *pvData, DWORD *pcbData, BOOL fIgnoreHKCU, void *pvDefaultData, DWORD dwDefaultDataSize);
ULONG_PTR SetClassLongPtrA(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
DWORD GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, int c, LPWORD pgi, unknown_t fl);
void lstat(const char *path, void *buf);
BOOL SetConsoleTitleW(LPCWSTR lpConsoleTitle);
BOOL DeletePrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProcessorName);
DWORD CredUIConfirmCredentialsA(PCSTR pszTargetName, BOOL bConfirm);
BOOL UnmapViewOfFile2(HANDLE Process, PVOID BaseAddress, ULONG UnmapFlags);
DWORD GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, int c, LPWORD pgi, unknown_t fl);
HBITMAP CreateDIBitmap(HDC hdc, unknown_t *lpbmih, unknown_t fdwInit, VOID *lpbInit, BITMAPINFO *lpbmi, unknown_t fuUsage);
BOOL CredDeleteW(LPCWSTR TargetName, DWORD Type, DWORD Flags);
HPOWERNOTIFY RegisterPowerSettingNotification(HANDLE hRecipient, LPCGUID PowerSettingGuid, DWORD Flags);
LSTATUS RegQueryMultipleValuesA(HKEY hKey, PVALENTA val_list, DWORD num_vals, LPSTR lpValueBuf, LPDWORD ldwTotsize);
BOOL SetConsoleTitleA(LPCSTR lpConsoleTitle);
double cos(double x);
BOOL IsInternetESCEnabled();
HRESULT SHGetPropertyStoreFromParsingName(PCWSTR pszPath, unknown_t *pbc, unknown_t flags, REFIID riid, void **ppv);
BOOL DeletePrintProcessorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPrintProcessorName);
BOOL FlushViewOfFile(LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlush);
HRESULT SHCreateItemWithParent(unknown_t pidlParent, unknown_t *psfParent, unknown_t pidl, REFIID riid, void **ppvItem);
int WSAEnumNetworkEvents(SOCKET s, WSAEVENT hEventObject, LPWSANETWORKEVENTS lpNetworkEvents);
DWORD CredUIConfirmCredentialsW(PCWSTR pszTargetName, BOOL bConfirm);
BOOL SymFromInlineContext(HANDLE hProcess, DWORD64 Address, ULONG InlineContext, PDWORD64 Displacement, PSYMBOL_INFO Symbol);
int humanize_number(char *buf);
ULONG ldap_controls_free(LDAPControlA **Controls);
CONFIGRET CM_Query_And_Remove_SubTree_ExA(DEVINST dnAncestor, unknown_t pVetoType, LPSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine);
BOOLEAN RtlTimeToSecondsSince1970(PLARGE_INTEGER Time, PULONG ElapsedSeconds);
DWORD PowerReadACValue(HKEY RootPowerKey, GUID *SchemeGuid, GUID *SubGroupOfPowerSettingsGuid, GUID *PowerSettingGuid, PULONG Type, LPBYTE Buffer, LPDWORD BufferSize);
BOOL WSAGetQOSByName(SOCKET s, LPWSABUF lpQOSName, LPQOS lpQOS);
HRESULT SafeArrayAccessData(unknown_t *psa, void **ppvData);
BOOL UpdateProcThreadAttribute(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, DWORD dwFlags, DWORD_PTR Attribute, PVOID lpValue, SIZE_T cbSize, PVOID lpPreviousValue, PSIZE_T lpReturnSize);
HRESULT LoadRegTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid, unknown_t **pptlib);
BOOL EnumCalendarInfoA(CALINFO_ENUMPROCA lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType);
HRESULT VarR8Pow(double dblLeft, double dblRight, double *pdblResult);
int fegetround();
BOOL CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded);
BOOL SetMailslotInfo(HANDLE hMailslot, DWORD lReadTimeout);
CONFIGRET CM_Query_And_Remove_SubTree_ExW(DEVINST dnAncestor, unknown_t pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine);
HRESULT VarI1FromBool(unknown_t boolIn, CHAR *pcOut);
BOOL GetWsChanges(HANDLE hProcess, PPSAPI_WS_WATCH_INFORMATION lpWatchInfo, DWORD cb);
SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerExW(LPCWSTR lpServiceName, unknown_t lpHandlerProc, LPVOID lpContext);
NTSTATUS BCryptCreateContext(ULONG dwTable, LPCWSTR pszContext, PCRYPT_CONTEXT_CONFIG pConfig);
ULONG ldap_value_free(PCHAR *vals);
int isdigit(int c);
NTSTATUS BCryptSecretAgreement(BCRYPT_KEY_HANDLE hPrivKey, BCRYPT_KEY_HANDLE hPubKey, BCRYPT_SECRET_HANDLE *phAgreedSecret, ULONG dwFlags);
PCHAR SymSetHomeDirectory(HANDLE hProcess, PCSTR dir);
HANDLE CreateMutexExA(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
BOOL EnumCalendarInfoW(CALINFO_ENUMPROCW lpCalInfoEnumProc, LCID Locale, CALID Calendar, CALTYPE CalType);
BOOL CryptUninstallDefaultContext(HCRYPTDEFAULTCONTEXT hDefaultContext, DWORD dwFlags, void *pvReserved);
HRESULT ProgIDFromCLSID(unknown_t clsid, LPOLESTR *lplpszProgID);
BOOL CertDeleteCRLFromStore(PCCRL_CONTEXT pCrlContext);
SECURITY_STATUS NCryptRegisterProtectionDescriptorName(LPCWSTR pwszName, LPCWSTR pwszDescriptorString, DWORD dwFlags);
void FreeAddrInfoExW(unknown_t pAddrInfoEx);
char * strchr(const char *s, int c);
BOOL QueryProcessAffinityUpdateMode(HANDLE hProcess, LPDWORD lpdwFlags);
int MenuItemFromPoint(HWND hWnd, HMENU hMenu, POINT ptScreen);
HRESULT SHAssocEnumHandlers(PCWSTR pszExtra, unknown_t afFilter, unknown_t **ppEnumHandler);
BOOL CryptUninstallCancelRetrieval(DWORD dwFlags, void *pvReserved);
int FoldStringW(DWORD dwMapFlags, LPCWCH lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest);
long double truncl(long double x);
SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerExA(LPCSTR lpServiceName, unknown_t lpHandlerProc, LPVOID lpContext);
long lrint(double x);
BOOL CertSerializeCTLStoreElement(PCCTL_CONTEXT pCtlContext, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement);
HANDLE CreateMutexExW(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
BOOL MoveFileWithProgressA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags);
HRESULT VarUI8FromDec(DECIMAL *pdecIn, ULONG64 *pi64Out);
float truncf(float x);
int FoldStringA(DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest);
char * tmpnam(char *s);
BOOL StrToIntExA(PCSTR pszString, unknown_t dwFlags, int *piRet);
float ceilf(float x);
CONFIGRET CM_Open_Device_Interface_Key_ExW(LPCWSTR pszDeviceInterface, REGSAM samDesired, unknown_t Disposition, PHKEY phkDeviceInterface, ULONG ulFlags, HMACHINE hMachine);
BOOL GetProcessHandleCount(HANDLE hProcess, PDWORD pdwHandleCount);
PVOID AddVectoredContinueHandler(ULONG First, unknown_t Handler);
VOID QueryInterruptTime(PULONGLONG lpInterruptTime);
UINT GetMenuDefaultItem(HMENU hMenu, UINT fByPos, UINT gmdiFlags);
BOOL MoveFileWithProgressW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, DWORD dwFlags);
int WSCUpdateProvider32(LPGUID lpProviderId, WCHAR *lpszProviderDllPath, const LPWSAPROTOCOL_INFOW lpProtocolInfoList, DWORD dwNumberOfEntries, LPINT lpErrno);
long double ceill(long double x);
BOOL KillTimer(HWND hWnd, UINT_PTR uIDEvent);
HRESULT RsopAccessCheckByType(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pPrincipalSelfSid, unknown_t pRsopToken, DWORD dwDesiredAccessMask, POBJECT_TYPE_LIST pObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING pGenericMapping, PPRIVILEGE_SET pPrivilegeSet, LPDWORD pdwPrivilegeSetLength, LPDWORD pdwGrantedAccessMask, LPBOOL pbAccessStatus);
CONFIGRET CM_Query_Arbitrator_Free_Data_Ex(PVOID pData, ULONG DataLen, DEVINST dnDevInst, RESOURCEID ResourceID, ULONG ulFlags, HMACHINE hMachine);
BOOL StrToIntExW(PCWSTR pszString, unknown_t dwFlags, int *piRet);
BOOL FlatSB_GetScrollPropPtr(HWND ARG_0, int propIndex, PINT_PTR ARG_2);
BOOL DrawFrameControl(HDC ARG_0, LPRECT ARG_1, UINT ARG_2, UINT ARG_3);
BOOL PhysicalToLogicalPointForPerMonitorDPI(HWND hWnd, LPPOINT lpPoint);
BOOL EndUpdateResourceW(HANDLE hUpdate, BOOL fDiscard);
HWND GetAncestor(HWND hwnd, UINT gaFlags);
BOOL CryptMsgUpdate(HCRYPTMSG hCryptMsg, BYTE *pbData, DWORD cbData, BOOL fFinal);
BOOL SetWindowOrgEx(HDC hdc, int X, int Y, LPPOINT lpPoint);
CONFIGRET CM_Open_Device_Interface_Key_ExA(LPCSTR pszDeviceInterface, REGSAM samDesired, unknown_t Disposition, PHKEY phkDeviceInterface, ULONG ulFlags, HMACHINE hMachine);
BOOL GetProfileType(DWORD *dwFlags);
BOOL AddAuditAccessAce(PACL pAcl, DWORD dwAceRevision, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure);
PVOID AddVectoredExceptionHandler(ULONG First, unknown_t Handler);
BOOL LineDDA(int nXStart, int nYStart, int nXEnd, int nYEnd, unknown_t lpLineFunc, LPARAM lpData);
HRESULT VarDecFromBool(unknown_t boolIn, DECIMAL *pdecOut);
BOOL EndUpdateResourceA(HANDLE hUpdate, BOOL fDiscard);
void * memchr(void *s, int c, size_t n);
struct IStream * SHOpenRegStreamA(HKEY hkey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD grfMode);
BOOL SHRegGetBoolUSValueW(LPCWSTR pszSubKey, LPCWSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault);
HRESULT GetRecordInfoFromGuids(REFGUID rGuidTypeLib, ULONG uVerMajor, ULONG uVerMinor, LCID lcid, REFGUID rGuidTypeInfo, unknown_t **ppRecInfo);
BOOL SymGetScopeW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, PSYMBOL_INFOW Symbol);
HANDLE OpenFileMappingW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
HCURSOR SetCursor(HCURSOR hCursor);
PVOID MapViewOfFileNuma2(HANDLE FileMappingHandle, HANDLE ProcessHandle, ULONG64 Offset, PVOID BaseAddress, SIZE_T ViewSize, ULONG AllocationType, ULONG PageProtection, ULONG PreferredNode);
BOOL AccessCheckByTypeResultList(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccessList, LPDWORD AccessStatusList);
HRESULT SHGetThreadRef(IUnknown **ppunk);
int mbtowc(wchar_t *pwc, const char *s, size_t n);
struct IStream * SHOpenRegStreamW(HKEY hkey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD grfMode);
BOOL CryptSIPLoad(GUID *pgSubject, DWORD dwFlags, unknown_t *pSipDispatch);
BOOL SHRegGetBoolUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, BOOL fIgnoreHKCU, BOOL fDefault);
HANDLE OpenFileMappingA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
BOOL InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount, DWORD Flags);
HRESULT ConnectToConnectionPoint(IUnknown *punk, REFIID riidEvent, BOOL fConnect, IUnknown *punkTarget, DWORD *pdwCookie, unknown_t **ppcpOut);
PRUNTIME_FUNCTION RtlLookupFunctionEntry(ULONG_PTR ControlPc, PULONG_PTR ImageBase, PUNWIND_HISTORY_TABLE HistoryTable);
NTSTATUS BCryptDeriveKeyCapi(BCRYPT_HASH_HANDLE hHash, BCRYPT_ALG_HANDLE hTargetAlg, PUCHAR pbDerivedKey, ULONG cbDerivedKey, ULONG dwFlags);
int system(const char *string);
DWORD SymAddrIncludeInlineTrace(HANDLE hProcess, DWORD64 Address);
BOOL ImageList_DragMove(int x, int y);
HRESULT SHReleaseThreadRef();
BOOL PathIsUNCServerA(LPCSTR pszPath);
DWORD GetConsoleOriginalTitleW(LPWSTR lpConsoleTitle, DWORD nSize);
BOOL GetProcessDefaultLayout(DWORD *pdwDefaultLayout);
HRESULT VarUdateFromDate(unknown_t dateIn, ULONG dwFlags, unknown_t *pudateOut);
DWORD SuspendThread(HANDLE hThread);
PIMAGE_SECTION_HEADER ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders, PVOID Base, ULONG Rva);
BOOL GetConsoleCursorInfo(HANDLE hConsoleOutput, PCONSOLE_CURSOR_INFO lpConsoleCursorInfo);
int fclose(FILE *stream);
BOOL CopyRect(LPRECT lprcDst, RECT *lprcSrc);
BOOL SetDecompressorInformation(DECOMPRESSOR_HANDLE DecompressorHandle, COMPRESS_INFORMATION_CLASS CompressInformationClass, LPCVOID CompressInformation, SIZE_T CompressInformationSize);
BOOL IsTokenUntrusted(HANDLE TokenHandle);
ULONG EventWriteTransfer(REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor, LPCGUID ActivityId, LPCGUID RelatedActivityId, ULONG UserDataCount, PEVENT_DATA_DESCRIPTOR UserData);
HMODULE LoadLibraryW(LPCWSTR lpLibFileName);
BOOL PathIsUNCServerW(LPCWSTR pszPath);
double remainder(double x, double y);
int iswspace(wint_t wc);
BOOL NCryptIsKeyHandle(NCRYPT_KEY_HANDLE hKey);
BOOL CloseHandle(HANDLE hObject);
BOOL SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit);
BOOL DestroyIcon(HICON hIcon);
HRESULT VarBstrFromDec(DECIMAL *pdecIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
BOOL QueryServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
DWORD GetConsoleOriginalTitleA(LPSTR lpConsoleTitle, DWORD nSize);
LSTATUS RegOverridePredefKey(HKEY hKey, HKEY hNewHKey);
HRESULT PathCreateFromUrlAlloc(PCWSTR pszIn, PWSTR *ppszOut, DWORD dwFlags);
VOID ber_bvfree(BERVAL *pBerVal);
LSTATUS SHRegSetUSValueA(LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwType, const void *pvData, DWORD cbData, DWORD dwFlags);
BOOL IsBadWritePtr(LPVOID lp, UINT_PTR ucb);
BOOL WSACloseEvent(WSAEVENT hEvent);
SECURITY_STATUS NCryptTranslateHandle(NCRYPT_PROV_HANDLE *phProvider, NCRYPT_KEY_HANDLE *phKey, HCRYPTPROV hLegacyProv, HCRYPTKEY hLegacyKey, DWORD dwLegacyKeySpec, DWORD dwFlags);
__attribute__((noreturn)) VOID RtlRaiseException(PEXCEPTION_RECORD ExceptionRecord);
BOOL LookupAccountNameLocalA(LPCSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
int EnumICMProfilesA(HDC hDC, unknown_t lpEnumICMProfilesFunc, LPARAM lParam);
HMODULE LoadLibraryA(LPCSTR lpLibFileName);
HRESULT VarOr(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
BOOL QueryServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
BOOL LogonUserW(LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken);
BOOL SetProcessPreferredUILanguages(DWORD dwFlags, PCZZWSTR pwszLanguagesBuffer, PULONG pulNumLanguages);
NTSTATUS BCryptDecrypt(BCRYPT_KEY_HANDLE hKey, PUCHAR pbInput, ULONG cbInput, VOID *pPaddingInfo, PUCHAR pbIV, ULONG cbIV, PUCHAR pbOutput, ULONG cbOutput, ULONG *pcbResult, ULONG dwFlags);
HRESULT VarEqv(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
HRESULT SHGetInstanceExplorer();
BOOL K32InitializeProcessForWsWatch(HANDLE hProcess);
BOOL QueryUmsThreadInformation(PUMS_CONTEXT UmsThread, UMS_THREAD_INFO_CLASS UmsThreadInfoClass, PVOID UmsThreadInformation, ULONG UmsThreadInformationLength, PULONG ReturnLength);
BOOL ScaleViewportExtEx(HDC hdc, int Xnum, int Xdenom, int Ynum, int Ydenom, LPSIZE lpSize);
ATOM AddAtomW(LPCWSTR lpString);
BOOL HeapDestroy(HANDLE hHeap);
BOOL LogonUserA(LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken);
BOOL SetThreadDesktop(HDESK hDesktop);
BOOL LookupAccountNameLocalW(LPCWSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
DWORD GdiGetBatchLimit();
BOOL SymGetSymbolFile(HANDLE hProcess, PCSTR SymPath, PCSTR ImageFile, DWORD Type, PSTR SymbolFile, size_t cSymbolFile, PSTR DbgFile, size_t cDbgFile);
BOOL FindClose(HANDLE hFindFile);
LSTATUS SHRegSetUSValueW(LPCWSTR pwzSubKey, LPCWSTR pwzValue, DWORD dwType, const void *pvData, DWORD cbData, DWORD dwFlags);
BOOL QueryServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
INT VariantTimeToSystemTime(DOUBLE vtime, LPSYSTEMTIME lpSystemTime);
BOOL CheckDlgButton(HWND hDlg, int nIDButton, UINT uCheck);
int EnumICMProfilesW(HDC hDC, unknown_t lpEnumICMProfilesFunc, LPARAM lParam);
CONFIGRET CM_Delete_Device_Interface_Key_ExW(LPCWSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine);
ATOM AddAtomA(LPCSTR lpString);
DWORD GetQueueStatus(UINT flags);
SECURITY_STATUS NCryptCreateClaim(NCRYPT_KEY_HANDLE hSubjectKey, NCRYPT_KEY_HANDLE hAuthorityKey, DWORD dwClaimType, unknown_t *pParameterList, PBYTE pbClaimBlob, DWORD cbClaimBlob, DWORD *pcbResult, DWORD dwFlags);
HRESULT SHGetIDListFromObject(IUnknown *punk, PIDLIST_ABSOLUTE *ppidl);
BOOL GetPointerFrameTouchInfoHistory(UINT32 pointerId, UINT32 *entriesCount, UINT32 *pointerCount, unknown_t *touchInfo);
CONFIGRET CM_Set_HW_Prof_FlagsA(DEVINSTID_A pDeviceID, ULONG ulConfig, ULONG ulValue, ULONG ulFlags);
BOOL CredIsProtectedA(LPSTR pszProtectedCredentials, CRED_PROTECTION_TYPE *pProtectionType);
COLORREF SetDCPenColor(HDC hdc, COLORREF crColor);
int FindNLSStringEx(LPCWSTR lpLocaleName, DWORD dwFindNLSStringFlags, LPCWSTR lpStringSource, int cchSource, LPCWSTR lpStringValue, int cchValue, LPINT pcchFound, LPNLSVERSIONINFO lpVersionInformation, LPVOID lpReserved, LPARAM sortHandle);
long GetObjectA(HGDIOBJ hgdiobj, int cbBuffer, LPVOID lpvObject);
double sqrt(double x);
BOOL QueryServiceStatus(SC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus);
HRESULT VarFormatPercent(LPVARIANT pvarIn, int iNumDig, int iIncLead, int iUseParens, int iGroup, ULONG dwFlags, BSTR *pbstrOut);
BOOL K32GetWsChanges(HANDLE hProcess, PPSAPI_WS_WATCH_INFORMATION lpWatchInfo, DWORD cb);
CONFIGRET CM_Delete_Device_Interface_Key_ExA(LPCSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine);
BOOL LeaveCriticalPolicySection(HANDLE hSection);
HANDLE WSAAsyncGetServByPort(HWND hWnd, u_int wMsg, int port, const char *proto, char *buf, int buflen);
long GetObjectW(HGDIOBJ hgdiobj, int cbBuffer, LPVOID lpvObject);
BOOL CredIsProtectedW(LPWSTR pszProtectedCredentials, CRED_PROTECTION_TYPE *pProtectionType);
int remove(const char *filename);
CONFIGRET CM_Set_HW_Prof_FlagsW(DEVINSTID_W pDeviceID, ULONG ulConfig, ULONG ulValue, ULONG ulFlags);
double lgamma(double x);
CONFIGRET CM_Get_Class_Key_Name_ExA(LPGUID ClassGuid, LPSTR pszKeyName, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL ResizePalette(HPALETTE hpal, UINT nEntries);
HRESULT RegisterTypeLib(unknown_t *ptlib, LPCOLESTR szFullPath, LPCOLESTR szHelpDir);
int SHAnsiToAnsi(PCSTR pszSrc, PSTR pszDst, int cchBuf);
PSTR StrNCatA(PSTR psz1, PCSTR psz2, int cchMax);
BOOL GetStringTypeExA(LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType);
void clearerr(FILE *stream);
int strcmp(const char *s1, const char *s2);
VOID GetCurrentThreadStackLimits(PULONG_PTR LowLimit, PULONG_PTR HighLimit);
u_short htons(u_short hostshort);
BOOL ScrollDC(HDC hDC, int dx, int dy, RECT *lprcScroll, RECT *lprcClip, HRGN hrgnUpdate, LPRECT lprcUpdate);
BOOL ActivateKeyboardLayout(HKL hkl, UINT Flags);
HRESULT VarPow(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
CONFIGRET CM_Unregister_Device_Interface_ExW(LPCWSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine);
NTSTATUS RtlCharToInteger(PCSZ String, ULONG Base, PULONG Value);
int LdapUnicodeToUTF8(LPCWSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest);
HRESULT GetRect(DWORD dwAspect, LPRECTL pRect);
u_long htonl(u_long hostlong);
DWORD ExpandEnvironmentStringsW(LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize);
CONFIGRET CM_Get_Class_Key_Name_ExW(LPGUID ClassGuid, LPWSTR pszKeyName, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL GetStringTypeExW(LCID Locale, DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWORD lpCharType);
int wsprintfW(LPWSTR ARG_0, LPCWSTR ARG_1, unknown_t ...);
CONFIGRET CM_Unregister_Device_Interface_ExA(LPCSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine);
HGLOBAL LoadResource(HMODULE hModule, HRSRC hResInfo);
BOOL CryptDecodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo);
PWSTR StrNCatW(PWSTR psz1, PCWSTR psz2, int cchMax);
__uint64 htond(double Value);
BOOL PFXExportCertStore(HCERTSTORE hStore, unknown_t *pPFX, LPCWSTR szPassword, DWORD dwFlags);
__uint32 htonf(float Value);
DWORD ExpandEnvironmentStringsA(LPCSTR lpSrc, LPSTR lpDst, DWORD nSize);
INT GetNameByTypeW(LPGUID lpServiceType, LPWSTR lpServiceName, DWORD dwNameLength);
HCOLORSPACE SetColorSpace(HDC hDC, HCOLORSPACE hColorSpace);
UINT WinExec(LPCSTR lpCmdLine, UINT uCmdShow);
NTSTATUS BCryptSetProperty(BCRYPT_HANDLE hObject, LPCWSTR pszProperty, PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
BOOL CredReadA(LPCSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALA *Credential);
VOID SetSecurityAccessMask(SECURITY_INFORMATION SecurityInformation, LPDWORD DesiredAccess);
BOOL CryptFindCertificateKeyProvInfo(PCCERT_CONTEXT pCert, DWORD dwFlags, void *pvReserved);
PVOID VirtualAlloc2(HANDLE Process, PVOID BaseAddress, SIZE_T Size, ULONG AllocationType, ULONG PageProtection, unknown_t *ExtendedParameters, ULONG ParameterCount);
PCSTR SymSrvDeltaName(HANDLE hProcess, PCSTR SymPath, PCSTR Type, PCSTR File1, PCSTR File2);
CONFIGRET CM_Get_DevNode_Property_Keys_Ex(DEVINST dnDevInst, unknown_t *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags, HMACHINE hMachine);
int wsprintfA(LPSTR ARG_0, LPCSTR ARG_1, unknown_t ...);
LRESULT DispatchMessageW(unknown_t *lpMsg);
BOOL CredReadW(LPCWSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALW *Credential);
HMONITOR MonitorFromPoint(POINT pt, DWORD dwFlags);
HRESULT OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams);
CONFIGRET CM_Get_Parent(unknown_t pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
HACCEL LoadAcceleratorsA(HINSTANCE hInstance, LPCSTR lpTableName);
HRESULT AssocQueryStringW(unknown_t flags, unknown_t str, LPCWSTR pszAssoc, LPCWSTR pszExtra, LPWSTR pszOut, DWORD *pcchOut);
HRESULT VarI8FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, LONG64 *pi64Out);
BOOL AddMonitorA(LPSTR pName, int Level, unknown_t *pMonitors);
BOOL ClearCommError(HANDLE hFile, LPDWORD lpErrors, LPCOMSTAT lpStat);
INT GetNameByTypeA(LPGUID lpServiceType, LPSTR lpServiceName, DWORD dwNameLength);
BOOL CryptVerifySignatureW(HCRYPTHASH hHash, BYTE *pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey, LPCWSTR szDescription, DWORD dwFlags);
BOOL CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey);
int memcmp(const void *s1, const void *s2, size_t n);
HACCEL LoadAcceleratorsW(HINSTANCE hInstance, LPCWSTR lpTableName);
BOOL SymNextW(HANDLE hProcess, PSYMBOL_INFOW siw);
HRESULT VectorFromBstr(BSTR bstr, unknown_t **ppsa);
BOOL AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid);
LONG ChangeDisplaySettingsW(unknown_t *lpDevMode, DWORD dwFlags);
BOOL GetProductInfo(DWORD dwOSMajorVersion, DWORD dwOSMinorVersion, DWORD dwSpMajorVersion, DWORD dwSpMinorVersion, PDWORD pdwReturnedProductType);
BOOL SetUserGeoID(GEOID GeoId);
HRESULT VarFix(LPVARIANT pvarIn, LPVARIANT pvarResult);
BOOL SymGetSymFromAddr(HANDLE hProcess, DWORD dwAddr, PDWORD pdwDisplacement, PIMAGEHLP_SYMBOL Symbol);
int GetKeyboardLayoutList(int nBuff, HKL *lpList);
BOOL CryptVerifySignatureA(HCRYPTHASH hHash, BYTE *pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey, LPCSTR szDescription, DWORD dwFlags);
ULONG ldap_rename_ext(LDAP *ld, const PSTR dn, const PSTR NewRDN, const PSTR NewParent, INT DeleteOldRdn, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
LRESULT DispatchMessageA(unknown_t *lpMsg);
HRESULT AssocQueryStringA(unknown_t flags, unknown_t str, LPCSTR pszAssoc, LPCSTR pszExtra, LPSTR pszOut, DWORD *pcchOut);
BOOL AddMonitorW(LPSTR pName, int Level, unknown_t *pMonitors);
LSTATUS RegOpenCurrentUser(REGSAM samDesired, PHKEY phkResult);
int GetPolyFillMode(HDC hdc);
LONG ChangeDisplaySettingsA(unknown_t *lpDevMode, DWORD dwFlags);
BOOL SleepConditionVariableCS(PCONDITION_VARIABLE ConditionVariable, PCRITICAL_SECTION CriticalSection, DWORD dwMilliseconds);
CONFIGRET CM_Get_Device_ID_Size(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags);
BOOL SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR pSecurityDescriptor, SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest, SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet);
ULONG ldap_connect(LDAP *ld, struct l_timeval *timeout);
BOOL SetMenuItemBitmaps(HMENU hMenu, UINT uPosition, UINT uFlags, HBITMAP hBitmapUnchecked, HBITMAP hBitmapChecked);
BOOL VerQueryValueA(LPCVOID pBlock, LPCSTR lpSubBlock, LPVOID *lplpBuffer, PUINT puLen);
wint_t towupper(wint_t wc);
BOOL DnsHostnameToComputerNameA(LPCSTR Hostname, LPSTR ComputerName, LPDWORD nSize);
int SHAnsiToUnicode(PCSTR pszSrc, PWSTR pwszDst, int cwchBuf);
BOOL InvertRect(HDC hDC, RECT *lprc);
HRESULT SafeArrayAllocDescriptorEx(VARTYPE vt, UINT cDims, unknown_t **ppsaOut);
BOOL CancelSynchronousIo(HANDLE hThread);
NTSTATUS NtQueryObject(HANDLE Handle, unknown_t ObjectInformationClass, PVOID ObjectInformation, ULONG ObjectInformationLength, PULONG ReturnLength);
BOOL VerQueryValueW(LPCVOID pBlock, LPCWSTR lpSubBlock, LPVOID *lplpBuffer, PUINT puLen);
BOOL SymGetLineFromInlineContext(HANDLE hProcess, DWORD64 qwAddr, ULONG InlineContext, DWORD64 qwModuleBaseAddress, PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line64);
HRESULT GetProcessDpiAwareness(HANDLE hprocess, PROCESS_DPI_AWARENESS *value);
NTSTATUS NtOpenFile(PHANDLE FileHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PIO_STATUS_BLOCK IoStatusBlock, ULONG ShareAccess, ULONG OpenOptions);
COLORREF SetTextColor(HDC hdc, COLORREF crColor);
HRESULT VarDecNeg(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
HRESULT CoTreatAsClass(unknown_t clsidOld, unknown_t clsidNew);
size_t strlen(const char *s);
BOOL IsProcessInJob(HANDLE ProcessHandle, HANDLE JobHandle, PBOOL Result);
ULONG ldap_delete_s(LDAP *ld, PSTR dn);
CONFIGRET CM_Remove_SubTree_Ex(DEVINST dnAncestor, ULONG ulFlags, HMACHINE hMachine);
BOOL DnsHostnameToComputerNameW(LPCWSTR Hostname, LPWSTR ComputerName, LPDWORD nSize);
HRESULT PathCchAppend(PWSTR pszPath, size_t cchPath, PCWSTR pszMore);
FILE * freopen(const char *filename, const char *mode, FILE *stream);
ULONG ldap_modrdn2_sA(LDAP *ExternalHandle, const PSTR DistinguishedName, const PSTR NewDistinguishedName, INT DeleteOldRdn);
LPVOID CreateFiber(SIZE_T dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter);
HANDLE CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName);
LPWSTR PathFindExtensionW(LPCWSTR pszPath);
DWORD UnDecorateSymbolName(PCSTR name, PSTR outputString, DWORD maxStringLength, DWORD flags);
BOOL OemToCharA(LPCSTR pSrc, LPSTR pDst);
float modff(float value, float *iptr);
BOOL RemoveClipboardFormatListener(HWND hwnd);
DWORD GetProfileSectionW(LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize);
void strmode(int mode, char *bp);
BOOL GetNumaProximityNodeEx(ULONG ProximityId, PUSHORT NodeNumber);
BOOL RedrawWindow(HWND hWnd, RECT *lprcUpdate, HRGN hrgnUpdate, UINT flags);
long double modfl(long double value, long double *iptr);
void * memcpy(void *s1, const void *s2, size_t n);
ULONG ldap_modrdn2_sW(LDAP *ExternalHandle, PWSTR DistinguishedName, PWSTR NewDistinguishedName, INT DeleteOldRdn);
DWORD SizeofResource(HMODULE hModule, HRSRC hResInfo);
HANDLE CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName);
HWND CreateMDIWindowA(LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HINSTANCE hInstance, LPARAM lParam);
DWORD GetProfileSectionA(LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize);
BOOL PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType);
LPSTR PathFindExtensionA(LPCSTR pszPath);
void * objc_msgSend(void *instance, char *selector);
ULONG GetCommPorts(PULONG lpPortNumbers, ULONG uPortNumbersCount, PULONG puPortNumbersFound);
BOOL MapUserPhysicalPagesScatter(PVOID *VirtualAddresses, ULONG_PTR NumberOfPages, PULONG_PTR PageArray);
HBITMAP CreateBitmapIndirect();
BOOL OemToCharW(LPCSTR pSrc, LPWSTR pDst);
HRESULT CreateStdDispatch(IUnknown *punkOuter, void *pvThis, unknown_t *ptinfo, IUnknown **ppunkStdDisp);
HWND CreateMDIWindowW(LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HINSTANCE hInstance, LPARAM lParam);
unknown_t * getprotobynumber(int number);
ULONG ldap_compare_extW(LDAP *ld, PWSTR dn, PWSTR Attr, PWSTR Value, struct berval *Data, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, ULONG *MessageNumber);
LSTATUS RegReplaceKeyA(HKEY hKey, LPCSTR lpSubKey, LPCSTR lpNewFile, LPCSTR lpOldFile);
BOOL PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType);
CONFIGRET CM_Open_DevNode_Key(DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile, unknown_t Disposition, PHKEY phkDevice, ULONG ulFlags);
BOOL CryptMsgGetAndVerifySigner(HCRYPTMSG hCryptMsg, DWORD cSignerStore, HCERTSTORE *rghSignerStore, DWORD dwFlags, PCCERT_CONTEXT *ppSigner, DWORD *pdwSignerIndex);
wctype_t wctype(const char *property);
ULONG ldap_ufn2dn(const PSTR ufn, PSTR *pDn);
BOOL GetFileSizeEx(HANDLE hFile, PLARGE_INTEGER lpFileSize);
DWORD GetFileAttributesW(LPCWSTR lpFileName);
BOOL SetStdHandle(DWORD nStdHandle, HANDLE hHandle);
BOOL SetViewportOrgEx(HDC hdc, int X, int Y, LPPOINT lpPoint);
HRESULT SafeArrayGetUBound(unknown_t *psa, UINT nDim, LONG *plUbound);
LSTATUS RegReplaceKeyW(HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpNewFile, LPCWSTR lpOldFile);
CONFIGRET CM_Get_Device_Interface_ListA(LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, PZZSTR Buffer, ULONG BufferLen, ULONG ulFlags);
BOOL FindClosePrinterChangeNotification();
ULONG ldap_compare_extA(LDAP *ld, const PSTR dn, const PSTR Attr, const PSTR Value, struct berval *Data, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
BOOL GetNumaProcessorNode(UCHAR Processor, PUCHAR NodeNumber);
BOOL HeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
PCCERT_CONTEXT CertCreateSelfSignCertificate(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey, PCERT_NAME_BLOB pSubjectIssuerBlob, DWORD dwFlags, PCRYPT_KEY_PROV_INFO pKeyProvInfo, PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm, PSYSTEMTIME pStartTime, PSYSTEMTIME pEndTime, PCERT_EXTENSIONS pExtensions);
int close(int fildes);
ULONG LHashValOfNameSysA(unknown_t syskind, LCID lcid, LPCSTR szName);
DWORD GetFileAttributesA(LPCSTR lpFileName);
int wprintf(wchar_t *format);
HRESULT CoCreateInstance(unknown_t rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID *ppv);
int ImageList_ReplaceIcon(HIMAGELIST himl, int i, HICON hicon);
BOOL CryptVerifyCertificateSignatureEx(HCRYPTPROV_LEGACY hCryptProv, DWORD dwCertEncodingType, DWORD dwSubjectType, void *pvSubject, DWORD dwIssuerType, void *pvIssuer, DWORD dwFlags, void *pvExtra);
BOOL InSendMessage();
BOOL ColorCorrectPalette(HDC hDC, HPALETTE hPalette, DWORD dwFirstEntry, DWORD dwNumOfEntries);
BOOL ChangeMenuW(HMENU hMenu, UINT cmd, LPCWSTR lpszNewItem, UINT cmdInsert, UINT flags);
CONFIGRET CM_Get_Device_Interface_ListW(LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR Buffer, ULONG BufferLen, ULONG ulFlags);
int abs(int j);
float asinf(float x);
HRESULT VarI2FromDec(DECIMAL *pdecIn, SHORT *psOut);
double asinh(double x);
int GetWindowRgn(HWND hWnd, HRGN hRgn);
BOOL SetProcessRestrictionExemption(BOOL fEnableExemption);
LRESULT SendMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL StrIsIntlEqualW(BOOL fCaseSens, PCWSTR pszString1, PCWSTR pszString2, int nChar);
BOOL ChangeMenuA(HMENU hMenu, UINT cmd, LPCSTR lpszNewItem, UINT cmdInsert, UINT flags);
long double asinl(long double x);
LSTATUS SHRegGetValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue, unknown_t srrfFlags, DWORD *pdwType, void *pvData, DWORD *pcbData);
int GetDlgCtrlID(HWND hWnd);
BOOL ControlService(SC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus);
BOOL SymGetSearchPath(HANDLE hProcess, PSTR SearchPath, DWORD SearchPathLength);
BOOL InitializeEnclave(HANDLE hProcess, LPVOID lpAddress, LPCVOID lpEnclaveInformation, DWORD dwInfoLength, LPDWORD lpEnclaveError);
int vfwprintf(FILE *stream, wchar_t *format, va_list arg);
VOID WakeConditionVariable(PCONDITION_VARIABLE ConditionVariable);
SOCKET WSAJoinLeaf(SOCKET s, struct sockaddr *name, int namelen, LPWSABUF lpCallerData, LPWSABUF lpCalleeData, LPQOS lpSQOS, LPQOS lpGQOS, DWORD dwFlags);
int fts_set_INODE64(void *ftsp, void *f, int options);
BOOL CheckTokenMembership(HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember);
BOOL PlayEnhMetaFileRecord(HDC hdc, unknown_t lpHandletable, unknown_t *lpEnhMetaRecord, UINT nHandles);
BOOL PostQueuedCompletionStatus(HANDLE CompletionPort, DWORD dwNumberOfBytesTransferred, ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped);
BOOL StrIsIntlEqualA(BOOL fCaseSens, PCSTR pszString1, PCSTR pszString2, int nChar);
long GetRandomRgn(HDC hdc, HRGN HRGN, INT iNum);
LRESULT SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL GetMemoryErrorHandlingCapabilities(PULONG Capabilities);
int getopt(int argc, const char **argv, const char *optstring);
LSTATUS SHRegGetValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue, unknown_t srrfFlags, DWORD *pdwType, void *pvData, DWORD *pcbData);
DWORD WinHttpGetProxySettingsVersion(HINTERNET hSession, DWORD *pdwProxySettingsVersion);
HANDLE OpenFileMappingFromApp(ULONG DesiredAccess, BOOL InheritHandle, PCWSTR Name);
long SetBitmapBits(HBITMAP hbmp, DWORD cBytes, VOID *lpBits);
CONFIGRET CM_Add_IDA(DEVINST dnDevInst, PSTR pszID, ULONG ulFlags);
BOOL FileTimeToDosDateTime(FILETIME *lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime);
BOOL SymSrvGetFileIndexStringW(HANDLE hProcess, PCWSTR SrvPath, PCWSTR File, PWSTR Index, size_t Size, DWORD Flags);
ULONG ber_skip_tag(BerElement *pBerElement, ULONG *pLen);
BOOL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue);
UINT GetKBCodePage();
int GetUserDefaultLocaleName(LPWSTR lpLocaleName, int cchLocaleName);
CONFIGRET CM_Add_IDW(DEVINST dnDevInst, PWSTR pszID, ULONG ulFlags);
ULONG ber_peek_tag(BerElement *pBerElement, ULONG *pLen);
ULONG UnregisterTraceGuids(TRACEHANDLE RegistrationHandle);
HRESULT QISearch(void *that, unknown_t pqit, REFIID riid, void **ppv);
HRESULT CreateClassMoniker(unknown_t rclsid, unknown_t *ppmk);
LPWSTR lstrcpyW(LPWSTR lpString1, LPCWSTR lpString2);
int iswupper(wint_t wc);
unknown_t * SafeArrayCreateEx(VARTYPE vt, UINT cDims, unknown_t *rgsabound, PVOID pvExtra);
HRESULT SHCreateItemInKnownFolder(unknown_t kfid, DWORD dwKFFlags, PCWSTR pszItem, REFIID riid, void **ppv);
BOOL EnumTimeFormatsEx(TIMEFMT_ENUMPROCEX lpTimeFmtEnumProcEx, LPCWSTR lpLocaleName, DWORD dwFlags, LPARAM lParam);
BOOL UrlIsNoHistoryW(PCWSTR pszURL);
BOOL VirtualUnlock(LPVOID lpAddress, SIZE_T dwSize);
UINT GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize);
BOOL GetClipCursor(LPRECT lpRect);
BOOL PathIsUNCA(LPCSTR pszPath);
int StartDocA(HDC hdc, unknown_t *pDocInfo);
LPSTR lstrcpyA(LPSTR lpString1, LPCSTR lpString2);
UINT SetBoundsRect(HDC hdc, RECT *lprcBounds, UINT flags);
BOOL PathAddExtensionW(LPWSTR pszPath, LPCWSTR pszExt);
char * strcpy_chk(char *dest, const char *src);
int StartDocW(HDC hdc, unknown_t *pDocInfo);
UINT GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize);
BOOL GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize);
BOOL UrlIsNoHistoryA(PCSTR pszURL);
BOOL PathIsUNCW(LPCWSTR pszPath);
LSTATUS RegSetValueExA(HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, BYTE *lpData, DWORD cbData);
HRESULT CreateDispTypeInfo(unknown_t *pidata, LCID lcid, unknown_t **pptinfo);
BOOL PathAddExtensionA(LPSTR pszPath, LPCSTR pszExt);
DWORD PrepareTape(HANDLE hDevice, DWORD dwOperation, BOOL bImmediate);
BOOL SymInitialize(HANDLE hProcess, PCSTR UserSearchPath, BOOL fInvadeProcess);
BOOL CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize);
ULONG ldap_modrdn2_s(LDAP *ExternalHandle, const PSTR DistinguishedName, const PSTR NewDistinguishedName, INT DeleteOldRdn);
float remquof(float x, float y, int *pquo);
long double powl(long double x, long double y);
BOOL OffsetViewportOrgEx(HDC hdc, int nXOffset, int nYOffset, LPPOINT lpPoint);
int StrCmpNA(PCSTR psz1, PCSTR psz2, int nChar);
long double remquol(long double x, long double y, int *pquo);
SECURITY_STATUS NCryptUnprotectSecret(NCRYPT_DESCRIPTOR_HANDLE *phDescriptor, DWORD dwFlags, BYTE *pbProtectedBlob, ULONG cbProtectedBlob, unknown_t *pMemPara, HWND hWnd, BYTE **ppbData, ULONG *pcbData);
BOOL ImageList_DrawEx(HIMAGELIST himl, int i, HDC hdcDst, int x, int y, int dx, int dy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle);
BOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR *NewDescriptor, BOOL IsDirectoryObject, HANDLE Token, PGENERIC_MAPPING GenericMapping);
float powf(float x, float y);
DWORD GetFirmwareEnvironmentVariableExA(LPCSTR lpName, LPCSTR lpGuid, PVOID pBuffer, DWORD nSize, PDWORD pdwAttribubutes);
LSTATUS RegSetValueExW(HKEY hKey, LPCWSTR lpValueName, DWORD Reserved, DWORD dwType, BYTE *lpData, DWORD cbData);
BOOL CertSaveStore(HCERTSTORE hCertStore, DWORD dwEncodingType, DWORD dwSaveAs, DWORD dwSaveTo, void *pvSaveToPara, DWORD dwFlags);
HDC BeginPaint(HWND hWnd, LPPAINTSTRUCT lpPaint);
int WSACleanup();
PCHAR * ldap_get_values(LDAP *ld, LDAPMessage *entry, const PSTR attr);
BOOL SymRegisterFunctionEntryCallback64(HANDLE hProcess, PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction, ULONG64 UserContext);
DWORD GetFirmwareEnvironmentVariableExW(LPCWSTR lpName, LPCWSTR lpGuid, PVOID pBuffer, DWORD nSize, PDWORD pdwAttribubutes);
int MessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType);
LPVOID VirtualAllocExNuma(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect, DWORD nndPreferred);
int StrCmpNW(PCWSTR psz1, PCWSTR psz2, int nChar);
BOOL DestroyMenu(HMENU hMenu);
CONFIGRET CM_Set_Class_Registry_PropertyW(LPGUID ClassGuid, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL DnsHostnameToComputerNameExW(LPCWSTR Hostname, LPWSTR ComputerName, LPDWORD nSize);
INT WSANSPIoctl(HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer, LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion);
HRESULT GetAppContainerRegistryLocation(REGSAM desiredAccess, PHKEY phAppContainerKey);
BOOL DrawIcon(HDC hDC, int X, int Y, HICON hIcon);
HCURSOR LoadCursorFromFileW(LPCWSTR lpFileName);
int WSAEnumProtocolsW(LPINT lpiProtocols, LPWSAPROTOCOL_INFOW lpProtocolBuffer, LPDWORD lpdwBufferLength);
BOOL PathIsSameRootA(LPCSTR pszPath1, LPCSTR pszPath2);
NTSTATUS NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS SystemInformationClass, PVOID SystemInformation, ULONG SystemInformationLength, PULONG ReturnLength);
int MessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType);
DWORD CertNameToStrA(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName, DWORD dwStrType, LPSTR psz, DWORD csz);
BOOL CryptHashData(HCRYPTHASH hHash, BYTE *pbData, DWORD dwDataLen, DWORD dwFlags);
HCURSOR LoadCursorFromFileA(LPCSTR lpFileName);
BOOL PathIsSameRootW(LPCWSTR pszPath1, LPCWSTR pszPath2);
BOOL CloseCompressor(COMPRESSOR_HANDLE CompressorHandle);
CONFIGRET CM_Set_Class_Registry_PropertyA(LPGUID ClassGuid, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags, HMACHINE hMachine);
HRESULT RegisterScaleChangeNotifications(DISPLAY_DEVICE_TYPE displayDevice, HWND hwndNotify, UINT uMsgNotify, DWORD *pdwCookie);
HRESULT VarCyNeg(unknown_t cyIn, unknown_t pcyResult);
DWORD CertNameToStrW(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName, DWORD dwStrType, LPWSTR psz, DWORD csz);
BOOL SetPrivateObjectSecurityEx(SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor, ULONG AutoInheritFlags, PGENERIC_MAPPING GenericMapping, HANDLE Token);
char * inet_ntoa(unsigned long in);
BOOL SymSetExtendedOption(IMAGEHLP_EXTENDED_OPTIONS option, BOOL value);
HRESULT SafeArrayCopyData(unknown_t *psaSource, unknown_t *psaTarget);
int WPUCloseSocketHandle(SOCKET s, LPINT lpErrno);
int WSAEnumProtocolsA(LPINT lpiProtocols, LPWSAPROTOCOL_INFOA lpProtocolBuffer, LPDWORD lpdwBufferLength);
DWORD GetMetaFileBitsEx(HMETAFILE hmf, UINT nSize, LPVOID lpvData);
int getchar();
int ExcludeUpdateRgn(HDC hDC, HWND hWnd);
BOOL DeleteUmsCompletionList(PUMS_COMPLETION_LIST UmsCompletionList);
BOOL SymMatchStringW(PCWSTR string, PCWSTR expression, BOOL fCase);
CONFIGRET CM_Disable_DevNode_Ex(DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
void ColorRGBToHLS(COLORREF clrRGB, WORD *pwHue, WORD *pwLuminance, WORD *pwSaturation);
HRESULT AssocQueryKeyW(unknown_t flags, unknown_t key, LPCWSTR pszAssoc, LPCWSTR pszExtra, HKEY *phkeyOut);
PVOID SymFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase);
BOOL CoDosDateTimeToFileTime(WORD nDosDate, WORD nDosTime, FILETIME *lpFileTime);
int snprintf_chk(char *s, size_t size, const char *format, va_list args);
BOOL IsTokenRestricted(HANDLE TokenHandle);
ULONG ldap_compare_ext(LDAP *ld, const PSTR dn, const PSTR Attr, const PSTR Value, struct berval *Data, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
HRESULT PathCchAddExtension(PWSTR pszPath, size_t cchPath, PCWSTR pszExt);
ATOM GlobalDeleteAtom(ATOM nAtom);
BOOL SetNamedPipeHandleState(HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout);
INT GetAddrInfoExCancel(LPHANDLE lpHandle);
NTSTATUS BCryptGenerateKeyPair(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_KEY_HANDLE *phKey, ULONG dwLength, ULONG dwFlags);
HRESULT AssocQueryKeyA(unknown_t flags, unknown_t key, LPCSTR pszAssoc, LPCSTR pszExtra, HKEY *phkeyOut);
BOOL SymFromAddrW(HANDLE hProcess, DWORD64 Address, PDWORD64 Displacement, PSYMBOL_INFOW Symbol);
int WSCSetApplicationCategory(LPCWSTR Path, DWORD PathLength, LPCWSTR Extra, DWORD ExtraLength, DWORD PermittedLspCategories, DWORD *pPrevPermLspCat, LPINT lpErrno);
int SHGetIconOverlayIndexA(LPCSTR pszIconPath, unknown_t iIconIndex);
BOOL SymFromIndex(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, PSYMBOL_INFO Symbol);
BOOL GetUmsCompletionListEvent(PUMS_COMPLETION_LIST UmsCompletionList, PHANDLE UmsCompletionEvent);
LPSTR PathFindFileNameA(LPCSTR pszPath);
intmax_t strtoimax(const char *str, char **endptr, int base);
int SHGetIconOverlayIndexW(LPCWSTR pszIconPath, unknown_t iIconIndex);
BOOL GetUserPreferredUILanguages(DWORD dwFlags, PULONG pulNumLanguages, PZZWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer);
BOOL DrawStateW(HDC hdc, HBRUSH hbrFore, unknown_t qfnCallBack, LPARAM lData, WPARAM wData, int x, int y, int cx, int cy, UINT uFlags);
LPWSTR PathFindFileNameW(LPCWSTR pszPath);
BOOL SendNotifyMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
CONFIGRET CM_Enable_DevNode(DEVINST dnDevInst, ULONG ulFlags);
HACCEL CreateAcceleratorTableA(LPACCEL paccel, int cAccel);
float tanhf(float x);
DWORD GetAppliedGPOListA(DWORD dwFlags, LPCSTR pMachineName, PSID pSidUser, GUID *pGuidExtension, PGROUP_POLICY_OBJECTA *ppGPOList);
BOOL DrawStateA(HDC hdc, HBRUSH hbrFore, unknown_t qfnCallBack, LPARAM lData, WPARAM wData, int x, int y, int cx, int cy, UINT uFlags);
BOOL SendNotifyMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
DWORD GetEnhMetaFileHeader(HENHMETAFILE hemf, UINT cbBuffer, unknown_t lpemh);
BOOL VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType);
void CoFreeAllLibraries();
PIMAGE_ARM64_RUNTIME_FUNCTION_ENTRY RtlLookupFunctionEntryCHPE(ULONG_PTR ControlPc, PULONG_PTR ImageBase, PVOID HistoryTable);
BOOL PlgBlt(HDC hdcDest, POINT *lpPoint, HDC hdcSrc, int nXSrc, int nYSrc, int nWidth, int nHeight, HBITMAP hbmMask, int xMask, int yMask);
long double tanhl(long double x);
BOOL CryptStringToBinaryA(LPCSTR pszString, DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags);
HANDLE GetClipboardData(UINT uFormat);
int GetStringScripts(DWORD dwFlags, LPCWSTR lpString, int cchString, LPWSTR lpScripts, int cchScripts);
NTSTATUS BCryptSignHash(BCRYPT_KEY_HANDLE hKey, VOID *pPaddingInfo, PUCHAR pbInput, ULONG cbInput, PUCHAR pbOutput, ULONG cbOutput, ULONG *pcbResult, ULONG dwFlags);
SIZE_T GlobalSize(HGLOBAL hMem);
CONFIGRET CM_Get_DevNode_Registry_Property_ExW(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
DWORD GetAppliedGPOListW(DWORD dwFlags, LPCWSTR pMachineName, PSID pSidUser, GUID *pGuidExtension, PGROUP_POLICY_OBJECTW *ppGPOList);
wchar_t * wcscat(wchar_t *s1, wchar_t *s2);
BOOL BlockInput(BOOL fBlockIt);
BOOL ResetDecompressor(DECOMPRESSOR_HANDLE DecompressorHandle);
BOOL SymFindFileInPathW(HANDLE hprocess, PCWSTR SearchPath, PCWSTR FileName, PVOID id, DWORD two, DWORD three, DWORD flags, PWSTR FoundFile, PFINDFILEINPATHCALLBACKW callback, PVOID context);
int WSCUpdateProvider(LPGUID lpProviderId, WCHAR *lpszProviderDllPath, const LPWSAPROTOCOL_INFOW lpProtocolInfoList, DWORD dwNumberOfEntries, LPINT lpErrno);
int iscntrl(int c);
int isalnum(int c);
HINTERNET WinHttpConnect(HINTERNET hSession, LPCWSTR pswzServerName, INTERNET_PORT nServerPort, DWORD dwReserved);
HACCEL CreateAcceleratorTableW(LPACCEL paccel, int cAccel);
BOOL CryptVerifyDetachedMessageSignature(PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, DWORD dwSignerIndex, BYTE *pbDetachedSignBlob, DWORD cbDetachedSignBlob, DWORD cToBeSigned, BYTE **rgpbToBeSigned, DWORD *rgcbToBeSigned, PCCERT_CONTEXT *ppSignerCert);
size_t wcstombs(char *s, wchar_t *pwcs, size_t n);
int isgraph(int c);
CONFIGRET CM_Setup_DevNode_Ex(DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
CONFIGRET CM_Get_DevNode_Registry_Property_ExA(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL ReadEventLogW(HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded);
BOOL CryptStringToBinaryW(LPCWSTR pszString, DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags);
ULONG ldap_search_ext_sW(LDAP *ld, PWSTR base, ULONG scope, PWSTR filter, PZPWSTR attrs, ULONG attrsonly, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, struct l_timeval *timeout, ULONG SizeLimit, PLDAPMessage *res);
BOOL GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb);
BOOL PFXIsPFXBlob(unknown_t *pPFX);
BOOL MoveWindow(HWND hWnd, int X, int Y, int nWidth, int nHeight, BOOL bRepaint);
long double remainderl(long double x, long double y);
BOOL GetProfilesDirectoryA(LPSTR lpProfileDir, LPDWORD lpcchSize);
void VariantInit(unknown_t *pvarg);
HRESULT VarCyFromDec(DECIMAL *pdecIn, unknown_t *pcyOut);
HANDLE CreateJobObjectW(LPSECURITY_ATTRIBUTES lpJobAttributes, LPCWSTR lpName);
SIZE_T HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
BOOL SetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData);
BOOL CryptImportPKCS8(unknown_t sPrivateKeyAndParams, DWORD dwFlags, HCRYPTPROV *phCryptProv, void *pvAuxInfo);
NTSTATUS BCryptGetProperty(BCRYPT_HANDLE hObject, LPCWSTR pszProperty, PUCHAR pbOutput, ULONG cbOutput, ULONG *pcbResult, ULONG dwFlags);
float remainderf(float x, float y);
double rint(double x);
LSTATUS SHQueryInfoKeyA(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen);
struct IStream * SHCreateMemStream(BYTE *pInit, UINT cbInit);
BOOL GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, unknown_t lpABCF);
PCSTR SymSrvGetSupplement(HANDLE hProcess, PCSTR SymPath, PCSTR Node, PCSTR File);
BOOL MiniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile, MINIDUMP_TYPE DumpType, unknown_t ExceptionParam, PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
BOOL ReadEventLogA(HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded);
HANDLE CreateJobObjectA(LPSECURITY_ATTRIBUTES lpJobAttributes, LPCSTR lpName);
BOOL GetProcessTimes(HANDLE hProcess, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime);
PWSTR StrChrNIW(PCWSTR pszStart, WCHAR wMatch, UINT cchMax);
BOOL GetProfilesDirectoryW(LPWSTR lpProfileDir, LPDWORD lpcchSize);
BOOL SetCalendarInfoA(LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData);
ULONG ldap_search_ext_sA(LDAP *ld, const PSTR base, ULONG scope, const PSTR filter, PZPSTR attrs, ULONG attrsonly, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, struct l_timeval *timeout, ULONG SizeLimit, PLDAPMessage *res);
SECURITY_STATUS NCryptEnumKeys(NCRYPT_PROV_HANDLE hProvider, LPCWSTR pszScope, unknown_t **ppKeyName, PVOID *ppEnumState, DWORD dwFlags);
BOOL GetCharABCWidthsFloatW(HDC hdc, UINT iFirstChar, UINT iLastChar, unknown_t lpABCF);
int feof(FILE *stream);
int openat(int fd, const char *path, int oflag);
LSTATUS SHQueryInfoKeyW(HKEY hkey, LPDWORD pcSubKeys, LPDWORD pcchMaxSubKeyLen, LPDWORD pcValues, LPDWORD pcchMaxValueNameLen);
GEOID GetUserGeoID(GEOCLASS GeoClass);
BOOL CertAddSerializedElementToStore(HCERTSTORE hCertStore, BYTE *pbElement, DWORD cbElement, DWORD dwAddDisposition, DWORD dwFlags, DWORD dwContextTypeFlags, DWORD *pdwContextType, const void **ppvContext);
NTSTATUS BCryptGenerateSymmetricKey(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_KEY_HANDLE *phKey, PUCHAR pbKeyObject, ULONG cbKeyObject, PUCHAR pbSecret, ULONG cbSecret, ULONG dwFlags);
INT WSCEnableNSProvider(LPGUID lpProviderId, BOOL fEnable);
BOOL SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase, ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType, PVOID pInfo);
BOOL FrameRgn(HDC hdc, HRGN HRGN, HBRUSH hbr, int nWidth, int nHeight);
int WSANtohs(SOCKET s, u_short netshort, u_short *lphostshort);
int MulDiv(int nNumber, int nNumerator, int nDenominator);
int WSANtohl(SOCKET s, u_long netlong, u_long *lphostlong);
BOOL ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped);
BOOL QueryFullProcessImageNameW(HANDLE hProcess, DWORD dwFlags, LPWSTR lpExeName, PDWORD lpdwSize);
BOOL DeactivateActCtx(DWORD dwFlags, ULONG_PTR ulCookie);
int GetDateFormatEx(LPCWSTR lpLocaleName, DWORD dwFlags, SYSTEMTIME *lpDate, LPCWSTR lpFormat, LPWSTR lpDateStr, int cchDate, LPCWSTR lpCalendar);
BOOL GetFormA(HPRINTER hPrinter, LPSTR pFormName, int Level, unknown_t pForm, int cbBuf, LPDWORD pcbNeeded);
BOOL QueryOptionalDelayLoadedAPI(HMODULE hParentModule, LPCSTR lpDllName, LPCSTR lpProcName, DWORD Reserved);
INT ber_flatten(BerElement *pBerElement, PBERVAL *pBerVal);
BOOL CryptInstallCancelRetrieval(unknown_t pfnCancel, const void *pvArg, DWORD dwFlags, void *pvReserved);
SECURITY_STATUS NCryptEncrypt(NCRYPT_KEY_HANDLE hKey, PBYTE pbInput, DWORD cbInput, VOID *pPaddingInfo, PBYTE pbOutput, DWORD cbOutput, DWORD *pcbResult, DWORD dwFlags);
PCCERT_SERVER_OCSP_RESPONSE_CONTEXT CertGetServerOcspResponseContext(HCERT_SERVER_OCSP_RESPONSE hServerOcspResponse, DWORD dwFlags, LPVOID pvReserved);
ULONG StartTraceA(PTRACEHANDLE TraceHandle, LPCSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
bool compat_mode(const char *function, const char *mode);
HRESULT AssocCreateForClasses(unknown_t *rgClasses, ULONG cClasses, REFIID riid, void **ppv);
char * fgets(char *s, int size, FILE *stream);
HICON LoadIconA(HINSTANCE hInstance, LPCSTR lpIconName);
BOOL ReadFileEx(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
BOOL GetFormW(HPRINTER hPrinter, LPWSTR pFormName, int Level, unknown_t pForm, int cbBuf, LPDWORD pcbNeeded);
BOOL SymRegisterCallbackW64(HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, ULONG64 UserContext);
ULONG ldap_create_page_control(PLDAP ExternalHandle, ULONG PageSize, struct berval *Cookie, UCHAR IsCritical, PLDAPControlA *Control);
BOOL QueryFullProcessImageNameA(HANDLE hProcess, DWORD dwFlags, LPSTR lpExeName, PDWORD lpdwSize);
BOOL ReadDirectoryChangesW(HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
ULONG StartTraceW(PTRACEHANDLE TraceHandle, LPCWSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
HANDLE SymFindDebugInfoFile(HANDLE hProcess, PCSTR FileName, PSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACK Callback, PVOID CallerData);
int fgetc(FILE *stream);
ULONG EventWrite(REGHANDLE RegHandle, PCEVENT_DESCRIPTOR EventDescriptor, ULONG UserDataCount, PEVENT_DATA_DESCRIPTOR UserData);
BOOL GetDisplayAutoRotationPreferencesByProcessId(DWORD dwProcessId, ORIENTATION_PREFERENCE *pOrientation, BOOL *fRotateScreen);
BOOL IsDBCSLeadByte(BYTE TestChar);
LSTATUS RegGetKeySecurity(HKEY hKey, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, LPDWORD lpcbSecurityDescriptor);
HICON LoadIconW(HINSTANCE hInstance, LPCWSTR lpIconName);
BOOL EnumCalendarInfoExEx(CALINFO_ENUMPROCEXEX pCalInfoEnumProcExEx, LPCWSTR lpLocaleName, CALID Calendar, LPCWSTR lpReserved, CALTYPE CalType, LPARAM lParam);
BOOL DrawAnimatedRects(HWND hwnd, int idAni, RECT *lprcFrom, RECT *lprcTo);
BOOL PathIsUNCServerShareA(LPCSTR pszPath);
double modf(double value, double *iptr);
int bind(SOCKET s, struct sockaddr *name, int namelen);
HRESULT CoGetTreatAsClass(unknown_t clsidOld, LPCLSID pClsidNew);
HWND GetNextDlgTabItem(HWND hDlg, HWND hCtl, BOOL bPrevious);
HBRUSH CreatePatternBrush();
int WSASend(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
BOOL DrawIconEx(HDC hdc, int xLeft, int yTop, HICON hIcon, int cxWidth, int cyWidth, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags);
BOOL GetPrinterDriverDirectoryA(LPSTR pName, LPSTR pEnvironment, int Level, LPBYTE pDriverDirectory, int cbBuf, LPDWORD pcbNeeded);
DWORD WinHttpWebSocketQueryCloseStatus(HINTERNET hWebSocket, USHORT *pusStatus, PVOID pvReason, DWORD dwReasonLength, DWORD *pdwReasonLengthConsumed);
BOOL PathIsUNCServerShareW(LPCWSTR pszPath);
BOOL LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid);
BOOL CryptUnregisterOIDInfo(PCCRYPT_OID_INFO pInfo);
WORD GetClassWord(HWND hWnd, int nIndex);
int StrCmpLogicalW(PCWSTR psz1, PCWSTR psz2);
BOOL SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine, BOOL Add);
HRESULT RegisterApplicationRecoveryCallback(APPLICATION_RECOVERY_CALLBACK pRecoveyCallback, PVOID pvParameter, DWORD dwPingInterval, DWORD dwFlags);
ULONG AVIFileRelease();
WSAEVENT WSACreateEvent();
BOOL LookupPrivilegeValueA(LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid);
BOOL GetPrinterDriverDirectoryW(LPWSTR pName, LPWSTR pEnvironment, int Level, LPBYTE pDriverDirectory, int cbBuf, LPDWORD pcbNeeded);
BOOL EnumLanguageGroupLocalesA(LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam);
DWORD ProcessGroupPolicyCompletedEx(unknown_t extensionId, unknown_t pAsyncHandle, DWORD dwStatus, HRESULT RsopStatus);
HRESULT UrlCombineA(PCSTR pszBase, PCSTR pszRelative, PSTR pszCombined, DWORD *pcchCombined, DWORD dwFlags);
HRESULT VarDateFromCy(unknown_t cyIn, unknown_t *pdateOut);
SC_LOCK LockServiceDatabase(SC_HANDLE hSCManager);
CONFIGRET CM_First_Range(unknown_t rlh, PDWORDLONG pullStart, PDWORDLONG pullEnd, unknown_t preElement, ULONG ulFlags);
int strcasecmp(const char *s1, const char *s2);
HRESULT SHAssocEnumHandlersForProtocolByApplication(PCWSTR protocol, REFIID riid, void **enumHandlers);
HRESULT UrlCombineW(PCWSTR pszBase, PCWSTR pszRelative, PWSTR pszCombined, DWORD *pcchCombined, DWORD dwFlags);
BOOL ShutdownBlockReasonCreate(HWND hWnd, LPCWSTR pwszReason);
VOID keybd_event(BYTE bVk, BYTE bScan, DWORD dwFlags, ULONG_PTR dwExtraInfo);
BOOL AddAccessDeniedAceEx(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid);
BOOL EnumLanguageGroupLocalesW(LANGGROUPLOCALE_ENUMPROCW lpLangGroupLocaleEnumProc, LGRPID LanguageGroup, DWORD dwFlags, LONG_PTR lParam);
BOOL AllocateUserPhysicalPages(HANDLE hProcess, PULONG_PTR NumberOfPages, PULONG_PTR PageArray);
BOOL SymGetLineNextW64(HANDLE hProcess, PIMAGEHLP_LINEW64 Line);
BOOL StrokeAndFillPath();
HRESULT CreateStdProgressIndicator(HWND hwndParent, LPCOLESTR pszTitle, unknown_t *pIbscCaller, unknown_t **ppIbsc);
BOOL PathQuoteSpacesA(LPSTR lpsz);
BOOL PathIsPrefixA(LPCSTR pszPrefix, LPCSTR pszPath);
ULONG EnableTraceEx(LPCGUID ProviderId, LPCGUID SourceId, TRACEHANDLE TraceHandle, ULONG IsEnabled, UCHAR Level, ULONGLONG MatchAnyKeyword, ULONGLONG MatchAllKeyword, ULONG EnableProperty, PEVENT_FILTER_DESCRIPTOR EnableFilterDesc);
CONFIGRET CM_Get_Resource_Conflict_DetailsA(unknown_t clConflictList, ULONG ulIndex, unknown_t pConflictDetails);
BOOL GetTouchInputInfo(HTOUCHINPUT hTouchInput, UINT cInputs, PTOUCHINPUT pInputs, int cbSize);
BOOL TzSpecificLocalTimeToSystemTime(unknown_t *lpTimeZoneInformation, SYSTEMTIME *lpLocalTime, LPSYSTEMTIME lpUniversalTime);
HRESULT PathCchAddBackslash(PWSTR pszPath, size_t cchPath);
BOOL GetNamedPipeServerSessionId(HANDLE Pipe, PULONG ServerSessionId);
BOOL PathQuoteSpacesW(LPWSTR lpsz);
HMONITOR MonitorFromRect(LPCRECT lprc, DWORD dwFlags);
BOOL UnloadUserProfile(HANDLE hToken, HANDLE hProfile);
LSTATUS RegCreateKeyTransactedA(HKEY hKey, LPCSTR lpSubKey, DWORD Reserved, LPSTR lpClass, DWORD dwOptions, REGSAM samDesired, const LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition, HANDLE hTransaction, PVOID pExtendedParemeter);
BOOL PathIsPrefixW(LPCWSTR pszPrefix, LPCWSTR pszPath);
bool isfinite(double x);
VOID FatalAppExitW(UINT uAction, LPCWSTR lpMessageText);
HRESULT OleLoadPictureFileEx(VARIANT varFileName, DWORD xSizeDesired, DWORD ySizeDesired, DWORD dwFlags, LPDISPATCH *lplpdispPicture);
BOOL GetMenuItemInfoW(HMENU hmenu, UINT item, BOOL fByPosition, LPMENUITEMINFOW lpmii);
SECURITY_STATUS NCryptOpenKey(NCRYPT_PROV_HANDLE hProvider, NCRYPT_KEY_HANDLE *phKey, LPCWSTR pszKeyName, DWORD dwLegacyKeySpec, DWORD dwFlags);
CONFIGRET CM_Get_Resource_Conflict_DetailsW(unknown_t clConflictList, ULONG ulIndex, unknown_t pConflictDetails);
BOOL _TrackMouseEvent(LPTRACKMOUSEEVENT lpEventTrack);
BOOL CryptUnprotectMemory(LPVOID pDataIn, DWORD cbDataIn, DWORD dwFlags);
BOOL CharToOemBuffW(LPCWSTR lpszSrc, LPSTR lpszDst, DWORD cchDstLength);
CONFIGRET CM_Enumerate_EnumeratorsA(ULONG ulEnumIndex, PSTR Buffer, PULONG pulLength, ULONG ulFlags);
LSTATUS RegCreateKeyTransactedW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LPWSTR lpClass, DWORD dwOptions, REGSAM samDesired, const LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition, HANDLE hTransaction, PVOID pExtendedParemeter);
VOID FatalAppExitA(UINT uAction, LPCSTR lpMessageText);
int WSASendTo(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, struct sockaddr *lpTo, int iTolen, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
HWND GetClipboardOwner();
BOOL CertCreateCTLEntryFromCertificateContextProperties(PCCERT_CONTEXT pCertContext, DWORD cOptAttr, PCRYPT_ATTRIBUTE rgOptAttr, DWORD dwFlags, void *pvReserved, PCTL_ENTRY pCtlEntry, DWORD *pcbCtlEntry);
BOOL GetMenuItemInfoA(HMENU hmenu, UINT item, BOOL fByPosition, LPMENUITEMINFOA lpmii);
BOOL QueryProtectedPolicy(LPCGUID PolicyGuid, PULONG_PTR PolicyValue);
BOOL GetMonitorInfoW(HMONITOR hMonitor, LPMONITORINFO lpmi);
HRESULT VarI4FromDisp(unknown_t *pdispIn, LCID lcid, LONG *plOut);
NTSTATUS BCryptDestroyHash(BCRYPT_HASH_HANDLE hHash);
HRESULT PathCchStripPrefix(PWSTR pszPath, size_t cchPath);
int StrCmpIW(PCWSTR psz1, PCWSTR psz2);
wchar_t * wcschr(wchar_t *s, wchar_t c);
DWORD WinHttpWriteProxySettings(HINTERNET hSession, BOOL fForceUpdate, unknown_t *pWinHttpProxySettings);
BOOL QueryServiceDynamicInformation(SERVICE_STATUS_HANDLE hServiceStatus, DWORD dwInfoLevel, PVOID *ppDynamicInfo);
HRESULT VarDecCmp(LPDECIMAL pdecLeft, LPDECIMAL pdecRight);
BOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR *ObjectDescriptor);
BOOL CharToOemBuffA(LPCSTR lpszSrc, LPSTR lpszDst, DWORD cchDstLength);
CONFIGRET CM_Enumerate_EnumeratorsW(ULONG ulEnumIndex, PWSTR Buffer, PULONG pulLength, ULONG ulFlags);
BOOL GetMonitorInfoA(HMONITOR hMonitor, LPMONITORINFO lpmi);
BOOL SymGetOmaps(HANDLE hProcess, DWORD64 BaseOfDll, POMAP *OmapTo, PDWORD64 cOmapTo, POMAP *OmapFrom, PDWORD64 cOmapFrom);
CONFIGRET CM_Disable_DevNode(DEVINST dnDevInst, ULONG ulFlags);
float cbrtf(float x);
NTSTATUS BCryptEnumContextFunctions(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, ULONG *pcbBuffer, PCRYPT_CONTEXT_FUNCTIONS *ppBuffer);
void InitCommonControls();
BOOL GetUpdateRect(HWND hWnd, LPRECT lpRect, BOOL bErase);
int iswprint(wint_t wc);
HENHMETAFILE SetWinMetaFileBits(UINT cbBuffer, BYTE *lpbBuffer, HDC hdcRef, unknown_t *lpmfp);
LPCSTR UrlGetLocationA(PCSTR pszURL);
HANDLE CreateWaitableTimerExW(LPSECURITY_ATTRIBUTES lpTimerAttributes, LPCWSTR lpTimerName, DWORD dwFlags, DWORD dwDesiredAccess);
HRESULT LoadIconMetric(HINSTANCE hinst, PCWSTR pszName, int lims, HICON *phico);
BOOL CertAddEnhancedKeyUsageIdentifier(PCCERT_CONTEXT pCertContext, LPCSTR pszUsageIdentifier);
BOOL GetTextMetricsW(HDC hdc, unknown_t lptm);
HRESULT CoQueryProxyBlanket(IUnknown *pProxy, DWORD *pwAuthnSvc, DWORD *pAuthzSvc, LPOLESTR *pServerPrincName, DWORD *pAuthnLevel, DWORD *pImpLevel, RPC_AUTH_IDENTITY_HANDLE *pAuthInfo, DWORD *pCapabilites);
BOOL DestroyCursor(HCURSOR hCursor);
BOOL QueryThreadCycleTime(HANDLE ThreadHandle, unknown_t CycleTime);
HWND CreateUpDownControl(DWORD dwStyle, int x, int y, int cx, int cy, HWND hParent, int nID, HINSTANCE hInst, HWND hBuddy, int nUpper, int nLower, int nPos);
long double cbrtl(long double x);
PVOID MapViewOfFile3(HANDLE FileMapping, HANDLE Process, PVOID BaseAddress, ULONG64 Offset, SIZE_T ViewSize, ULONG AllocationType, ULONG PageProtection, unknown_t *ExtendedParameters, ULONG ParameterCount);
SECURITY_STATUS NCryptNotifyChangeKey(NCRYPT_PROV_HANDLE hProvider, HANDLE *phEvent, DWORD dwFlags);
BOOL GetTextMetricsA(HDC hdc, unknown_t lptm);
BOOL CloseGestureInfoHandle(unknown_t hGestureInfo);
LPCWSTR UrlGetLocationW(PCWSTR pszURL);
HANDLE CreateWaitableTimerExA(LPSECURITY_ATTRIBUTES lpTimerAttributes, LPCSTR lpTimerName, DWORD dwFlags, DWORD dwDesiredAccess);
ULONG Release();
BOOL GetNumaProximityNode(ULONG ProximityId, PUCHAR NodeNumber);
void aligned_alloc(size_t alignment, size_t size);
BOOL FillConsoleOutputAttribute(HANDLE hConsoleOutput, WORD wAttribute, DWORD nLength, COORD dwWriteCoord, LPDWORD lpNumberOfAttrsWritten);
BOOL AbortSystemShutdownA(LPSTR lpMachineName);
BOOL GrayStringW(HDC hDC, HBRUSH hBrush, unknown_t lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight);
int WSCRemoveQOSTemplate(LPGUID Guid, LPWSABUF QosName);
BOOL CertVerifyValidityNesting(PCERT_INFO pSubjectInfo, PCERT_INFO pIssuerInfo);
BOOL GetColorAdjustment(HDC hdc, unknown_t lpca);
LPWCH GetEnvironmentStringsW();
PCERT_EXTENSION CertFindExtension(LPCSTR pszObjId, DWORD cExtensions, unknown_t *rgExtensions);
DWORD GetSecurityDescriptorRMControl(PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl);
HRESULT VarDiv(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
BOOL IsCharAlphaW(WCHAR ch);
HRESULT VarMod(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
BOOL AbortSystemShutdownW(LPWSTR lpMachineName);
BOOL GrayStringA(HDC hDC, HBRUSH hBrush, unknown_t lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight);
SECURITY_STATUS NCryptExportKey(NCRYPT_KEY_HANDLE hKey, NCRYPT_KEY_HANDLE hExportKey, LPCWSTR pszBlobType, unknown_t *pParameterList, PBYTE pbOutput, DWORD cbOutput, DWORD *pcbResult, DWORD dwFlags);
HWND GetTopWindow(HWND hWnd);
BOOL SetCaretPos(int X, int Y);
SIZE_T LocalShrink(HLOCAL hMem, UINT cbNewSize);
HRESULT SafeArrayDestroy(unknown_t *psa);
HRESULT VarUI8FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, ULONG64 *pi64Out);
BOOL EnumPrintProcessorsA(LPSTR pName, LPSTR pEnvironment, int Level, LPSTR pPrintProcessorInfo, int cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned);
HGDIOBJ SelectObject(HDC hdc, HGDIOBJ hgdiobj);
HWND SetClipboardViewer(HWND hWndNewViewer);
HDESK CreateDesktopW(LPCWSTR lpszDesktop, LPCWSTR lpszDevice, unknown_t *pDevmode, DWORD dwFlags, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa);
BOOL SymGetLineNext64(HANDLE hProcess, PIMAGEHLP_LINE64 Line);
BOOL FlushFileBuffers(HANDLE hFile);
int StrCmpCA(LPCSTR pszStr1, LPCSTR pszStr2);
BOOL IsCharAlphaA(CHAR ch);
HGLOBAL GlobalHandle(LPCVOID pMem);
DWORD WaitForMultipleObjectsEx(DWORD nCount, HANDLE *lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable);
PVOID DecodeSystemPointer(PVOID Ptr);
HRESULT OleCreatePictureIndirect(LPPICTDESC lpPictDesc, REFIID riid, BOOL fOwn, LPVOID *lplpvObj);
SIZE_T RtlCompareMemory(VOID *Source1, VOID *Source2, SIZE_T Length);
BOOL CredUnmarshalCredentialA(LPCSTR MarshaledCredential, PCRED_MARSHAL_TYPE CredType, PVOID *Credential);
CONFIGRET CM_Open_DevNode_Key_Ex(DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile, unknown_t Disposition, PHKEY phkDevice, ULONG ulFlags, HMACHINE hMachine);
BOOL CertIsStrongHashToSign(PCCERT_STRONG_SIGN_PARA pStrongSignPara, LPCWSTR pwszCNGHashAlgid, PCCERT_CONTEXT pSigningCert);
BOOL CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void *pvEncoded, DWORD *pcbEncoded);
HDESK CreateDesktopA(LPCSTR lpszDesktop, LPCSTR lpszDevice, unknown_t *pDevmode, DWORD dwFlags, ACCESS_MASK dwDesiredAccess, LPSECURITY_ATTRIBUTES lpsa);
DWORD GetCompressedFileSizeTransactedW(LPCWSTR lpFileName, LPDWORD lpFileSizeHigh, HANDLE hTransaction);
BOOL EnumPrintProcessorsW(LPWSTR pName, LPWSTR pEnvironment, int Level, LPWSTR pPrintProcessorInfo, int cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned);
BOOL WinHttpCreateUrl(LPURL_COMPONENTS lpUrlComponents, DWORD dwFlags, LPWSTR pwszUrl, LPDWORD pdwUrlLength);
UINT GetDpiForShellUIComponent(SHELL_UI_COMPONENT Arg1);
int StrCmpCW(LPCWSTR pszStr1, LPCWSTR pszStr2);
int AbortDoc();
BOOL CryptSIPGetSignedDataMsg(unknown_t *pSubjectInfo, DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg, BYTE *pbSignedDataMsg);
BOOL CredUnmarshalCredentialW(LPCWSTR MarshaledCredential, PCRED_MARSHAL_TYPE CredType, PVOID *Credential);
void longjmp(jmp_buf env, int val);
VOID SwitchToFiber(LPVOID lpFiber);
DWORD GetCompressedFileSizeTransactedA(LPCSTR lpFileName, LPDWORD lpFileSizeHigh, HANDLE hTransaction);
BOOLEAN TryAcquireSRWLockShared(PSRWLOCK SRWLock);
BOOL MoveToEx(HDC hdc, int X, int Y, LPPOINT lpPoint);
CONFIGRET CM_Get_Device_IDW(DEVINST dnDevInst, PWSTR Buffer, ULONG BufferLen, ULONG ulFlags);
BOOL LookupAccountNameA(LPCSTR lpSystemName, LPCSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
HRESULT VarBoolFromUI4(ULONG ulIn, unknown_t *pboolOut);
CONFIGRET CM_Get_Device_Interface_Property_ExW(LPCWSTR pszDeviceInterface, unknown_t *PropertyKey, unknown_t *PropertyType, PBYTE PropertyBuffer, PULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine);
BOOL GetFileAttributesExA(LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation);
NTSTATUS RtlConvertSidToUnicodeString(PUNICODE_STRING UnicodeString, PSID Sid, BOOLEAN AllocateDestinationString);
LSTATUS RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcchName, LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcchClass, PFILETIME lpftLastWriteTime);
HRESULT VarBoolFromUI1(BYTE bIn, unknown_t *pboolOut);
BOOL InvalidateRect(HWND hWnd, RECT *lpRect, BOOL bErase);
HRESULT VarBoolFromUI2(USHORT uiIn, unknown_t *pboolOut);
BOOL IsWinEventHookInstalled(DWORD event);
SECURITY_STATUS NCryptProtectSecret(NCRYPT_DESCRIPTOR_HANDLE hDescriptor, DWORD dwFlags, BYTE *pbData, ULONG cbData, unknown_t *pMemPara, HWND hWnd, BYTE **ppbProtectedBlob, ULONG *pcbProtectedBlob);
BOOL PostThreadMessageW(DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam);
HDESK OpenInputDesktop(DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
HRESULT VarR8Round(double dblIn, int cDecimals, double *pdblResult);
HRESULT CoGetObject(LPCWSTR pszName, unknown_t *pBindOptions, REFIID riid, void **ppv);
struct IStream * SHOpenRegStream2W(HKEY hkey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD grfMode);
HRESULT VarBoolFromUI8(ULONG64 i64In, unknown_t *pboolOut);
BOOL GetQueuedCompletionStatus(HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred, PULONG_PTR lpCompletionKey, LPOVERLAPPED *lpOverlapped, DWORD dwMilliseconds);
BOOL GetFileAttributesExW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation);
HCURSOR CopyCursor(HCURSOR hCursor);
BOOL WPUPostMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
HRESULT VarCyMulI4(unknown_t cyLeft, LONG lRight, unknown_t pcyResult);
BOOL PostThreadMessageA(DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL AssignProcessToJobObject(HANDLE hJob, HANDLE hProcess);
LSTATUS RegEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD lpcchName, LPDWORD lpReserved, LPWSTR lpClass, LPDWORD lpcchClass, PFILETIME lpftLastWriteTime);
BOOL PathRelativePathToA(LPSTR pszPath, LPCSTR pszFrom, DWORD dwAttrFrom, LPCSTR pszTo, DWORD dwAttrTo);
CONFIGRET CM_Get_Device_IDA(DEVINST dnDevInst, PSTR Buffer, ULONG BufferLen, ULONG ulFlags);
BOOL LookupAccountNameW(LPCWSTR lpSystemName, LPCWSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse);
HICON DuplicateIcon(HINSTANCE hInst, HICON hIcon);
void * memmove(void *s1, const void *s2, size_t n);
DWORD GetGuiResources(HANDLE hProcess, DWORD uiFlags);
int StrFromTimeIntervalA(PSTR pszOut, UINT cchMax, DWORD dwTimeMS, int digits);
int iswcntrl(wint_t wc);
DWORD SymGetModuleBase(HANDLE hProcess, DWORD dwAddr);
BOOL UnlockFileEx(HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped);
HRESULT VarI8FromDate(unknown_t dateIn, LONG64 *pi64Out);
LANGID GetSystemDefaultLangID();
BOOL CertFindSubjectInSortedCTL(PCRYPT_DATA_BLOB pSubjectIdentifier, PCCTL_CONTEXT pCtlContext, DWORD dwFlags, void *pvReserved, PCRYPT_DER_BLOB pEncodedAttributes);
HRESULT VarCyMulI8(unknown_t cyLeft, LONG64 lRight, unknown_t pcyResult);
ULONG RegisterTraceGuidsA(WMIDPREQUEST RequestAddress, PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount, PTRACE_GUID_REGISTRATION TraceGuidReg, LPCSTR MofImagePath, LPCSTR MofResourceName, PTRACEHANDLE RegistrationHandle);
struct IStream * SHOpenRegStream2A(HKEY hkey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD grfMode);
BOOL DuplicateToken(HANDLE ExistingTokenHandle, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, PHANDLE DuplicateTokenHandle);
BOOL GetThreadTimes(HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime);
float log1pf(float x);
BOOL SetThreadLocale(LCID Locale);
BOOL K32QueryWorkingSet(HANDLE hProcess, PVOID pv, DWORD cb);
int StrFromTimeIntervalW(PWSTR pszOut, UINT cchMax, DWORD dwTimeMS, int digits);
int ispunct(int c);
BOOL PathRelativePathToW(LPWSTR pszPath, LPCWSTR pszFrom, DWORD dwAttrFrom, LPCWSTR pszTo, DWORD dwAttrTo);
int SHUnicodeToAnsi(PCWSTR pwszSrc, PSTR pszDst, int cchBuf);
BOOL Wow64SetThreadContext(HANDLE hThread, unknown_t *lpContext);
long double log1pl(long double x);
BOOL CreateUmsThreadContext(PUMS_CONTEXT *lpUmsThread);
BOOL PeekConsoleInputW(HANDLE hConsoleInput, PINPUT_RECORD lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead);
HRESULT SHCreateShellItemArrayFromShellItem(unknown_t *psi, REFIID riid, void **ppv);
BOOL GetPhysicallyInstalledSystemMemory(PULONGLONG TotalMemoryInKilobytes);
ULONG ldap_modify_s(LDAP *ld, PSTR dn, unknown_t **mods);
BOOL IsZoomed(HWND hWnd);
__attribute__((noreturn)) VOID RaiseException(DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, ULONG_PTR *lpArguments);
FILE * popen(const char *filename, const char *mode);
BOOL CertUnregisterPhysicalStore(const void *pvSystemStore, DWORD dwFlags, LPCWSTR pwszStoreName);
NTSTATUS BCryptEnumContextFunctionProviders(ULONG dwTable, LPCWSTR pszContext, ULONG dwInterface, LPCWSTR pszFunction, ULONG *pcbBuffer, PCRYPT_CONTEXT_FUNCTION_PROVIDERS *ppBuffer);
ULONG RegisterTraceGuidsW(WMIDPREQUEST RequestAddress, PVOID RequestContext, LPCGUID ControlGuid, ULONG GuidCount, PTRACE_GUID_REGISTRATION TraceGuidReg, LPCWSTR MofImagePath, LPCWSTR MofResourceName, PTRACEHANDLE RegistrationHandle);
HRESULT CreateFileMoniker(LPCOLESTR lpszPathName, unknown_t *ppmk);
HANDLE SymFindExecutableImageW(HANDLE hProcess, PCWSTR FileName, PWSTR ImageFilePath, PFIND_EXE_FILE_CALLBACKW Callback, PVOID CallerData);
HCOLORSPACE GetColorSpace();
BOOL QueryInformationJobObject(HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength, LPDWORD lpReturnLength);
ULONG SetTraceCallback(LPCGUID pGuid, PEVENT_CALLBACK EventCallback);
BOOL GetCharWidth32A(HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer);
NTSTATUS NtClose(HANDLE Handle);
BOOL PeekConsoleInputA(HANDLE hConsoleInput, PINPUT_RECORD lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead);
PTP_WAIT CreateThreadpoolWait(PTP_WAIT_CALLBACK pfnwa, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
int ExtSelectClipRgn(HDC hdc, HRGN HRGN, unknown_t fnMode);
ULONG CloseTrace(TRACEHANDLE TraceHandle);
HRESULT DllCanUnloadNow();
COLORREF GetNearestPaletteIndex(HPALETTE hpal, COLORREF crColor);
LSTATUS RegDisablePredefinedCache();
BOOL GetCharWidth32W(HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer);
char * asctime(struct tm *timeptr);
int wcscmp(wchar_t *s1, wchar_t *s2);
HBITMAP CreateBitmap(int nWidth, int nHeight, UINT cPlanes, UINT cBitsPerPel, VOID *lpvBits);
BOOL AllocateLocallyUniqueId(PLUID Luid);
BOOL ValidateRgn(HWND hWnd, HRGN hRgn);
BOOL SetCompressorInformation(COMPRESSOR_HANDLE CompressorHandle, COMPRESS_INFORMATION_CLASS CompressInformationClass, LPCVOID CompressInformation, SIZE_T CompressInformationSize);
void * SHLockShared(HANDLE hData, DWORD dwProcessId);
void ImageList_EndDrag();
HBRUSH CreateSolidBrush();
BOOL SetInformationJobObject(HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength);
COLORREF GetDCBrushColor();
PVOID VirtualAlloc2FromApp(HANDLE Process, PVOID BaseAddress, SIZE_T Size, ULONG AllocationType, ULONG PageProtection, unknown_t *ExtendedParameters, ULONG ParameterCount);
SOCKET WSAAccept(SOCKET s, struct sockaddr *addr, LPINT addrlen, LPCONDITIONPROC lpfnCondition, DWORD_PTR dwCallbackData);
PLDAPSearch ldap_search_init_pageA(PLDAP ExternalHandle, const PSTR DistinguishedName, ULONG ScopeOfSearch, const PSTR SearchFilter, PZPSTR AttributeList, ULONG AttributesOnly, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG PageTimeLimit, ULONG TotalSizeLimit, PLDAPSortKeyA *SortKeys);
HRESULT VarDateFromI8(LONG64 i64In, unknown_t *pdateOut);
CONFIGRET CM_Set_DevNode_PropertyW(DEVINST dnDevInst, unknown_t *PropertyKey, unknown_t PropertyType, PBYTE PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags);
HRESULT VarDateFromI2(SHORT sIn, unknown_t *pdateOut);
HRESULT VarBoolFromDate(unknown_t dateIn, unknown_t *pboolOut);
HRESULT VarDateFromI1(CHAR cIn, unknown_t *pdateOut);
HRESULT VarDateFromI4(LONG lIn, unknown_t *pdateOut);
PLDAPSearch ldap_search_init_pageW(PLDAP ExternalHandle, PWSTR DistinguishedName, ULONG ScopeOfSearch, PWSTR SearchFilter, PZPWSTR AttributeList, ULONG AttributesOnly, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, ULONG PageTimeLimit, ULONG TotalSizeLimit, PLDAPSortKeyW *SortKeys);
BOOL EnumerateLoadedModules(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback, PVOID UserContext);
BOOL UpdateResourceW(HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb);
UINT RealGetWindowClassA(HWND hwnd, LPSTR ptszClassName, UINT cchClassNameMax);
DWORD WriteEncryptedFileRaw(PFE_IMPORT_FUNC pfImportCallback, PVOID pvCallbackContext, PVOID pvContext);
NTSTATUS BCryptCreateMultiHash(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_HASH_HANDLE *phHash, ULONG nHashes, PUCHAR pbHashObject, ULONG cbHashObject, PUCHAR pbSecret, ULONG cbSecret, ULONG dwFlags);
BOOL ObjectPrivilegeAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted);
BOOL DeleteFormA(HPRINTER hPrinter, LPSTR pFormName);
BOOL K32GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb);
CONFIGRET CM_Get_Res_Des_Data_Size_Ex(PULONG pulSize, RES_DES rdResDes, ULONG ulFlags, HMACHINE hMachine);
HGLOBAL GlobalAlloc(UINT uFlags, SIZE_T dwBytes);
HDC CreateICA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput, unknown_t *lpdvmInit);
BOOL ObjectPrivilegeAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted);
HRESULT SHGetPropertyStoreFromIDList(unknown_t pidl, unknown_t flags, REFIID riid, void **ppv);
DWORD GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize);
UINT RealGetWindowClassW(HWND hwnd, LPWSTR ptszClassName, UINT cchClassNameMax);
BOOL CheckTokenCapability(HANDLE TokenHandle, PSID CapabilitySidToCheck, PBOOL HasCapability);
BOOL HeapLock(HANDLE hHeap);
BOOL UpdateResourceA(HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cb);
BOOL GetPointerDeviceProperties(HANDLE device, UINT32 *propertyCount, unknown_t *pointerProperties);
BOOL SetThreadpoolThreadMinimum(PTP_POOL ptpp, DWORD cthrdMic);
HANDLE FindFirstFileNameTransactedW(LPCWSTR lpFileName, DWORD dwFlags, LPDWORD StringLength, PWSTR LinkName, HANDLE hTransaction);
BOOL DeleteFormW(HPRINTER hPrinter, LPWSTR pFormName);
BOOL SymGetLineFromAddrW64(HANDLE hProcess, DWORD64 dwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINEW64 Line);
BOOL QueryWorkingSetEx(HANDLE hProcess, PVOID pv, DWORD cb);
long SetDIBitsToDevice(HDC hdc, int XDest, int YDest, DWORD dwWidth, DWORD dwHeight, int XSrc, int YSrc, UINT uStartScan, UINT cScanLines, VOID *lpvBits, BITMAPINFO *lpbmi, unknown_t fuColorUse);
ULONG RemoveVectoredContinueHandler(PVOID Handle);
HDC CreateICW(LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, unknown_t *lpdvmInit);
HANDLE FindFirstFileExA(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags);
DWORD GetModuleBaseNameA(HANDLE hProcess, HMODULE hModule, LPSTR lpBaseName, DWORD nSize);
BOOL PolyBezierTo(HDC hdc, POINT *lppt, DWORD cCount);
int WPUQuerySocketHandleContext(SOCKET s, PDWORD_PTR lpContext, LPINT lpErrno);
double nextafter(double x, double y);
NTSTATUS NtQueryInformationThread(HANDLE ThreadHandle, THREADINFOCLASS ThreadInformationClass, PVOID ThreadInformation, ULONG ThreadInformationLength, PULONG ReturnLength);
size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
ULONG ldap_compareA(LDAP *ld, const PSTR dn, const PSTR attr, PSTR value);
BOOL GetDefaultCommConfigW(LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize);
HRESULT ImageList_WriteEx(HIMAGELIST himl, DWORD dwFlags, struct IStream *pstm);
HANDLE CreateFileMappingFromApp(HANDLE hFile, PSECURITY_ATTRIBUTES SecurityAttributes, ULONG PageProtection, ULONG64 MaximumSize, PCWSTR Name);
BOOL PrefetchVirtualMemory(HANDLE hProcess, ULONG_PTR NumberOfEntries, PWIN32_MEMORY_RANGE_ENTRY VirtualAddresses, ULONG Flags);
wchar_t * wcscpy(wchar_t *s1, wchar_t *s2);
HRESULT VarDateFromBool(unknown_t boolIn, unknown_t *pdateOut);
ULONG ldap_get_optionW(LDAP *ld, int option, void *outvalue);
HRGN CreateEllipticRgnIndirect();
BOOL SetSystemTimeAdjustmentPrecise(DWORD64 dwTimeAdjustment, BOOL bTimeAdjustmentDisabled);
HANDLE FindFirstFileExW(LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags);
ULONG ldap_compareW(LDAP *ld, PWSTR dn, PWSTR attr, PWSTR value);
HANDLE WSAAsyncGetHostByAddr(HWND hWnd, u_int wMsg, const char *addr, int len, int type, char *buf, int buflen);
UINT SetTextAlign(HDC hdc, unknown_t fMode);
BOOL ConvertStringSecurityDescriptorToSecurityDescriptorW(LPCWSTR StringSecurityDescriptor, DWORD StringSDRevision, PSECURITY_DESCRIPTOR *SecurityDescriptor, PULONG SecurityDescriptorSize);
VOID GetCurrentProcessorNumberEx(PPROCESSOR_NUMBER ProcNumber);
BOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision);
HICON ExtractIconA(HINSTANCE hInst, LPCSTR pszExeFileName, UINT nIconIndex);
BOOL GetDefaultCommConfigA(LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize);
INT WSASetSocketSecurity(SOCKET Socket, unknown_t *SecuritySettings, ULONG SecuritySettingsLen, LPWSAOVERLAPPED Overlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine);
HRESULT VarDateFromR4(FLOAT fltIn, unknown_t *pdateOut);
BOOL DestroyAcceleratorTable(HACCEL hAccel);
ULONG ldap_value_freeA(PCHAR *vals);
BOOL LogicalToPhysicalPoint(HWND hWnd, LPPOINT lpPoint);
BOOL GetDiskFreeSpaceExA(LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes);
CONFIGRET CM_Delete_Class_Key(LPGUID ClassGuid, ULONG ulFlags);
HRESULT VarDateFromR8(DOUBLE dblIn, unknown_t *pdateOut);
BOOL PathIsLFNFileSpecW(LPCWSTR pszName);
BOOL SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput);
BOOL ConvertStringSecurityDescriptorToSecurityDescriptorA(LPCSTR StringSecurityDescriptor, DWORD StringSDRevision, PSECURITY_DESCRIPTOR *SecurityDescriptor, PULONG SecurityDescriptorSize);
float nearbyintf(float x);
int LCMapStringA(LCID Locale, DWORD dwMapFlags, LPCSTR lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest);
VOID WinHttpFreeProxyResult(unknown_t *pProxyResult);
BOOL RefreshPolicyEx(BOOL bMachine, DWORD dwOptions);
HDWP DeferWindowPos(HDWP hWinPosInfo, HWND hWnd, HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags);
HICON ExtractIconW(HINSTANCE hInst, LPCWSTR pszExeFileName, UINT nIconIndex);
long double nearbyintl(long double x);
BOOL GetStringTypeW(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWORD lpCharType);
ULONG ldap_value_freeW(PWCHAR *vals);
BOOL CryptHashPublicKeyInfo(HCRYPTPROV_LEGACY hCryptProv, ALG_ID Algid, DWORD dwFlags, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, BYTE *pbComputedHash, DWORD *pcbComputedHash);
BOOL GetDiskFreeSpaceExW(LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes);
BOOL GetGUIThreadInfo(DWORD idThread, PGUITHREADINFO pgui);
BOOL PathIsLFNFileSpecA(LPCSTR pszName);
BOOLEAN RtlIsNameLegalDOS8Dot3(PUNICODE_STRING Name, POEM_STRING OemName, PBOOLEAN NameContainsSpaces);
int sprintf(char *s, const char *format, va_list args);
int MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCCH lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
HLOCAL LocalReAlloc(HLOCAL hMem, SIZE_T uBytes, UINT uFlags);
BOOL GetCursorPos(LPPOINT lpPoint);
int LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWSTR lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest);
LSTATUS SHRegCreateUSKeyW(LPCWSTR pwzPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags);
int GetMenuItemCount(HMENU hMenu);
LPVOID LocalLock(HLOCAL hMem);
HRESULT VarUI8FromR4(FLOAT fltIn, ULONG64 *pi64Out);
BOOL ConvertStringSidToSidW(LPCWSTR StringSid, PSID *Sid);
unknown_t * SafeArrayCreate(VARTYPE vt, UINT cDims, unknown_t *rgsabound);
HRESULT VarUI8FromR8(DOUBLE dblIn, ULONG64 *pi64Out);
BOOL IntersectRect(LPRECT lprcDst, RECT *lprcSrc1, RECT *lprcSrc2);
BOOL K32EnumProcesses(DWORD *lpidProcess, DWORD cb, LPDWORD lpcbNeeded);
BOOL GetStringTypeA(LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType);
HRESULT GetAdvise(DWORD *pAspects, DWORD *pAdvf, unknown_t **ppAdvSink);
BOOL SystemTimeToTzSpecificLocalTimeEx(unknown_t *lpTimeZoneInformation, SYSTEMTIME *lpUniversalTime, LPSYSTEMTIME lpLocalTime);
BOOL GetUILanguageInfo(DWORD dwFlags, PCZZWSTR pwmszLanguage, PZZWSTR pwszFallbackLanguages, PDWORD pcchFallbackLanguages, PDWORD pAttributes);
HRESULT SafeArraySetRecordInfo(unknown_t *psa, unknown_t *prinfo);
LSTATUS SHRegCreateUSKeyA(LPCSTR pszPath, REGSAM samDesired, HUSKEY hRelativeUSKey, PHUSKEY phNewUSKey, DWORD dwFlags);
BOOL SymSrvGetFileIndexString(HANDLE hProcess, PCSTR SrvPath, PCSTR File, PSTR Index, size_t Size, DWORD Flags);
BOOL GetViewportOrgEx(HDC hdc, LPPOINT lpPoint);
BOOL GlobalUnlock(HGLOBAL hMem);
BOOL ConvertStringSidToSidA(LPCSTR StringSid, PSID *Sid);
BOOL QueryUnbiasedInterruptTime(PULONGLONG UnbiasedTime);
HRESULT QueryInterface(REFIID iid, unknown_t *ppvObject);
BOOL FindVolumeClose(HANDLE hFindVolume);
BSTR SysAllocStringLen(unknown_t *strIn, UINT ui);
BOOL CompareObjectHandles(HANDLE hFirstObjectHandle, HANDLE hSecondObjectHandle);
HRESULT VarR8FromUI1(BYTE bIn, DOUBLE *pdblOut);
HRESULT VarR8FromUI2(USHORT uiIn, DOUBLE *pdblOut);
HRESULT CoCopyProxy(IUnknown *pProxy, IUnknown **ppCopy);
HRESULT VarR8FromUI4(ULONG ulIn, DOUBLE *pdblOut);
HANDLE FindFirstVolumeW(LPWSTR lpszVolumeName, DWORD cchBufferLength);
CONFIGRET CM_Invert_Range_List(unknown_t rlhOld, unknown_t rlhNew, DWORDLONG ullMaxValue, ULONG ulFlags);
DWORD TlsAlloc();
LONG_PTR SetWindowLongPtrW(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
double trunc(double x);
HRESULT VarR8FromUI8(ULONG64 ui64In, DOUBLE *pdblOut);
BOOL SetUmsThreadInformation(PUMS_CONTEXT UmsThread, UMS_THREAD_INFO_CLASS UmsThreadInfoClass, PVOID UmsThreadInformation, ULONG UmsThreadInformationLength);
BOOL SymAddSourceStream(HANDLE hProcess, ULONG64 Base, PCSTR StreamFile, PBYTE Buffer, size_t Size);
BOOL ShowWindow(HWND hWnd, int nCmdShow);
BOOL CredPackAuthenticationBufferA(DWORD dwFlags, LPSTR pszUserName, LPSTR pszPassword, PBYTE pPackedCredentials, DWORD *pcbPackedCredentials);
int rename(const char *oldpath, const char *newpath);
HANDLE SymFindDebugInfoFileW(HANDLE hProcess, PCWSTR FileName, PWSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACKW Callback, PVOID CallerData);
BOOL ReleaseMutex(HANDLE hMutex);
VOID SetFileApisToANSI();
SECURITY_STATUS NCryptCreatePersistedKey(NCRYPT_PROV_HANDLE hProvider, NCRYPT_KEY_HANDLE *phKey, LPCWSTR pszAlgId, LPCWSTR pszKeyName, DWORD dwLegacyKeySpec, DWORD dwFlags);
HANDLE FindFirstVolumeA(LPSTR lpszVolumeName, DWORD cchBufferLength);
BOOL K32EmptyWorkingSet(HANDLE hProcess);
BOOL IntlStrEqWorkerA(BOOL fCaseSens, LPCSTR lpString1, LPCSTR lpString2, int nChar);
HRESULT CoInvalidateRemoteMachineBindings(LPOLESTR pszMachineName);
int StrCSpnIW(PCWSTR pszStr, PCWSTR pszSet);
DWORD QueueUserAPC(PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData);
BOOL CredPackAuthenticationBufferW(DWORD dwFlags, LPWSTR pszUserName, LPWSTR pszPassword, PBYTE pPackedCredentials, DWORD *pcbPackedCredentials);
LONG_PTR SetWindowLongPtrA(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
long SetPrinterDataExA(HPRINTER hPrinter, LPSTR pKeyName, LPSTR pValueName, unknown_t Type, LPBYTE pData, int cbData);
HCOLORSPACE CreateColorSpaceW();
void * pututxline(void *utx);
BOOL GetWindowFeedbackSetting(HWND hwnd, FEEDBACK_TYPE feedback, DWORD dwFlags, UINT32 *pSize, VOID *config);
BOOL CryptFlushTimeValidObject(LPCSTR pszFlushTimeValidOid, LPVOID pvPara, PCCERT_CONTEXT pIssuer, DWORD dwFlags, LPVOID pvReserved);
BOOL IntlStrEqWorkerW(BOOL fCaseSens, LPCWSTR lpString1, LPCWSTR lpString2, int nChar);
ULONG TraceEventInstance(TRACEHANDLE TraceHandle, PEVENT_INSTANCE_HEADER EventTrace, PEVENT_INSTANCE_INFO InstInfo, PEVENT_INSTANCE_INFO ParentInstInfo);
INT WSAImpersonateSocketPeer(SOCKET Socket, struct sockaddr *PeerAddr, ULONG PeerAddrLen);
HCOLORSPACE CreateColorSpaceA();
BOOL CryptInstallOIDFunctionAddress(HMODULE hModule, DWORD dwEncodingType, LPCSTR pszFuncName, DWORD cFuncEntry, unknown_t *rgFuncEntry, DWORD dwFlags);
long SetPrinterDataExW(HPRINTER hPrinter, LPWSTR pKeyName, LPWSTR pValueName, unknown_t Type, LPBYTE pData, int cbData);
int StrCSpnIA(PCSTR pszStr, PCSTR pszSet);
BOOL SHCreateThreadWithHandle(LPTHREAD_START_ROUTINE pfnThreadProc, void *pData, unknown_t flags, LPTHREAD_START_ROUTINE pfnCallback, HANDLE *pHandle);
uint32_t srandom(uint32_t seed);
HRESULT CoRegisterClassObject(unknown_t rclsid, LPUNKNOWN pUnk, DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister);
BOOL DestroyCaret();
void DrawStatusTextA(HDC hDC, LPCRECT lprc, LPCSTR pszText, UINT uFlags);
HRESULT RsopResetPolicySettingStatus(DWORD dwFlags, unknown_t *pServices, unknown_t *pSettingInstance);
BOOL SymGetSourceFileChecksumW(HANDLE hProcess, ULONG64 Base, PCWSTR FileSpec, DWORD *pCheckSumType, BYTE *pChecksum, DWORD checksumSize, DWORD *pActualBytesWritten);
double frexp(double value, int *exp);
BOOL StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
ULONG ldap_get_next_page_s(PLDAP ExternalHandle, PLDAPSearch SearchHandle, struct l_timeval *timeout, ULONG PageSize, ULONG *TotalCount, LDAPMessage **Results);
BOOL GetSystemPowerStatus(LPSYSTEM_POWER_STATUS lpSystemPowerStatus);
int pclose(FILE *stream);
BOOL GetVolumeInformationByHandleW(HANDLE hFile, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize);
BOOL K32EnumProcessModules(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded);
ULONG ldap_close_extended_op(LDAP *ld, ULONG MessageNumber);
UINT GetSystemDirectoryW(LPWSTR lpBuffer, UINT uSize);
void DrawStatusTextW(HDC hDC, LPCRECT lprc, LPCWSTR pszText, UINT uFlags);
HRESULT CreateDataAdviseHolder(unknown_t *ppDAHolder);
BOOL GdiComment(HDC hdc, UINT cbSize, BYTE *lpData);
int WSAConnect(SOCKET s, struct sockaddr *name, int namelen, LPWSABUF lpCallerData, LPWSABUF lpCalleeData, LPQOS lpSQOS, LPQOS lpGQOS);
HRESULT VarDecFromDate(unknown_t dateIn, DECIMAL *pdecOut);
BOOL CancelShutdown();
unknown_t * gethostbyname(const char *name);
BOOL WinHelpA(HWND hWndMain, LPCSTR lpszHelp, UINT uCommand, ULONG_PTR dwData);
BOOL CryptDuplicateHash(HCRYPTHASH hHash, DWORD *pdwReserved, DWORD dwFlags, HCRYPTHASH *phHash);
int maskrune(uint32_t c, unsigned long f);
PVOID SymFunctionTableAccess(HANDLE hProcess, DWORD AddrBase);
HRESULT DeriveAppContainerSidFromAppContainerName(PCWSTR pszAppContainerName, PSID *ppsidAppContainerSid);
UINT GetSystemDirectoryA(LPSTR lpBuffer, UINT uSize);
HRESULT VarFormatNumber(LPVARIANT pvarIn, int iNumDig, int iIncLead, int iUseParens, int iGroup, ULONG dwFlags, BSTR *pbstrOut);
HRESULT VarWeekdayName(int iWeekday, int fAbbrev, int iFirstDay, ULONG dwFlags, BSTR *pbstrOut);
WORD CascadeWindows(HWND hwndParent, UINT wHow, RECT *lpRect, UINT cKids, HWND *lpKids);
HRESULT CoMarshalInterThreadInterfaceInStream(REFIID riid, LPUNKNOWN pUnk, LPSTREAM *ppStm);
BOOL FindActCtxSectionGuid(DWORD dwFlags, GUID *lpExtensionGuid, ULONG ulSectionId, GUID *lpGuidToFind, PACTCTX_SECTION_KEYED_DATA ReturnedData);
BOOL WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped);
BOOL DeriveCapabilitySidsFromName(LPCWSTR CapName, PSID **CapabilityGroupSids, DWORD *CapabilityGroupSidCount, PSID **CapabilitySids, DWORD *CapabilitySidCount);
HFILE _lopen(LPCSTR lpPathName, int iReadWrite);
BOOL WinHelpW(HWND hWndMain, LPCWSTR lpszHelp, UINT uCommand, ULONG_PTR dwData);
HRESULT OleLoadPicturePath(LPOLESTR szURLorPath, LPUNKNOWN punkCaller, DWORD dwReserved, OLE_COLOR clrReserved, REFIID riid, LPVOID *ppvRet);
int munmap(void *addr, size_t length);
BOOL ImageList_DragLeave(HWND hwndLock);
BOOL PathCompactPathExW(LPWSTR pszOut, LPCWSTR pszSrc, UINT cchMax, DWORD dwFlags);
BOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted);
BOOL SetThreadContext(HANDLE hThread, unknown_t *lpContext);
SECURITY_STATUS NCryptImportKey(NCRYPT_PROV_HANDLE hProvider, NCRYPT_KEY_HANDLE hImportKey, LPCWSTR pszBlobType, unknown_t *pParameterList, NCRYPT_KEY_HANDLE *phKey, PBYTE pbData, DWORD cbData, DWORD dwFlags);
HCERTSTORE CryptGetMessageCertificates(DWORD dwMsgAndCertEncodingType, HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, BYTE *pbSignedBlob, DWORD cbSignedBlob);
CONFIGRET CM_Get_Child(unknown_t pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
DWORD GetWinMetaFileBits(HENHMETAFILE hemf, UINT cbBuffer, LPBYTE lpbBuffer, INT fnMapMode, HDC hdcRef);
BOOL GetFileSecurityA(LPCSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
DWORD CredUIPromptForWindowsCredentialsW(PCREDUI_INFOW pUiInfo, DWORD dwAuthError, ULONG *pulAuthPackage, LPCVOID pvInAuthBuffer, ULONG ulInAuthBufferSize, LPVOID *ppvOutAuthBuffer, ULONG *pulOutAuthBufferSize, BOOL *pfSave, DWORD dwFlags);
int CombineRgn(HRGN HRGNDest, HRGN HRGNSrc1, HRGN HRGNSrc2, unknown_t fnCombineMode);
DWORD SetTapeParameters(HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation);
CONFIGRET CM_Locate_DevNodeA(unknown_t pdnDevInst, DEVINSTID_A pDeviceID, ULONG ulFlags);
BOOL CredFindBestCredentialW(LPCWSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALW *Credential);
HANDLE SetClipboardData(UINT uFormat, HANDLE hMem);
LSTATUS RegGetValueA(HKEY hkey, LPCSTR lpSubKey, LPCSTR lpValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData);
int WSCDeinstallProvider(LPGUID lpProviderId, LPINT lpErrno);
int chmod(const char *path, int mode);
BOOL GetTextExtentPointW(HDC hdc, LPCWSTR lpString, int cbString, LPSIZE lpSize);
DWORD CredUIPromptForWindowsCredentialsA(PCREDUI_INFOA pUiInfo, DWORD dwAuthError, ULONG *pulAuthPackage, LPCVOID pvInAuthBuffer, ULONG ulInAuthBufferSize, LPVOID *ppvOutAuthBuffer, ULONG *pulOutAuthBufferSize, BOOL *pfSave, DWORD dwFlags);
unknown_t * getprotobyname(const char *name);
BOOL PathCompactPathExA(LPSTR pszOut, LPCSTR pszSrc, UINT cchMax, DWORD dwFlags);
CONFIGRET CM_Locate_DevNodeW(unknown_t pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags);
BOOL CredFindBestCredentialA(LPCSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALA *Credential);
BOOL GetFileSecurityW(LPCWSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded);
ULONG ldap_set_dbg_flags(ULONG NewFlags);
int isupper(int c);
VOID GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo);
int GetMenuPosFromID(HMENU hmenu, UINT id);
HRESULT MIMEAssociationDialogW(HWND hwndParent, DWORD dwInFlags, LPCWSTR pcszFile, LPCWSTR pcszMIMEContentType, LPWSTR pszAppBuf, UINT ucAppBufLen);
uint32_t arc4random();
BOOL CryptDecrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen);
CONFIGRET CM_Get_DevNode_Registry_PropertyW(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
BOOL GetTextExtentPointA(HDC hdc, LPCSTR lpString, int cbString, LPSIZE lpSize);
BOOL FlattenPath();
LSTATUS RegGetValueW(HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData);
HRESULT VarCySub(unknown_t cyLeft, unknown_t cyRight, unknown_t pcyResult);
DWORD PowerRegisterSuspendResumeNotification(DWORD Flags, HANDLE Recipient, PHPOWERNOTIFY RegistrationHandle);
LONG DisplayConfigGetDeviceInfo(unknown_t *requestPacket);
HRESULT MIMEAssociationDialogA(HWND hwndParent, DWORD dwInFlags, LPCSTR pcszFile, LPCSTR pcszMIMEContentType, LPSTR pszAppBuf, UINT ucAppBufLen);
HRGN CreateRectRgnIndirect();
int iswctype(wint_t wc, wctype_t desc);
BOOL GetTextExtentPointI(HDC hdc, LPWORD pgiIn, int cgi, LPSIZE lpSize);
CONFIGRET CM_Get_DevNode_Registry_PropertyA(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
BOOL SetMessageQueue(int cMessagesMax);
BOOL UnhookWindowsHookEx(HHOOK hhk);
HRESULT SafeArrayUnaccessData(unknown_t *psa);
BOOL UnregisterTouchWindow(HWND hwnd);
BOOL FlatSB_EnableScrollBar(HWND ARG_0, int ARG_1, UINT ARG_2);
DWORD GetWindowThreadProcessId(HWND hWnd, LPDWORD lpdwProcessId);
BOOL ExtTextOutW(HDC hdc, int X, int Y, unknown_t fuOptions, RECT *lprc, LPCWSTR lpString, UINT cbCount, INT *lpDx);
void * reallocf(void *ptr, size_t size);
BOOL SetXStateFeaturesMask(PCONTEXT Context, DWORD64 FeatureMask);
VOID DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
CONFIGRET CM_Query_And_Remove_SubTreeA(DEVINST dnAncestor, unknown_t pVetoType, LPSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags);
ULONG LdapGetLastError();
char * user_from_uid(uid_t uid, int nouser);
HBRUSH GetSysColorBrush(int nIndex);
HRESULT SysAddRefString(BSTR bstrString);
int WSAHtons(SOCKET s, u_short hostshort, u_short *lpnetshort);
HRESULT VarUI1FromUI4(ULONG ulIn, BYTE *pbOut);
UINT _lwrite(HFILE hFile, LPCCH lpBuffer, UINT uBytes);
NTSTATUS BCryptOpenAlgorithmProvider(BCRYPT_ALG_HANDLE *phAlgorithm, LPCWSTR pszAlgId, LPCWSTR pszImplementation, ULONG dwFlags);
HRESULT VarUI1FromUI2(USHORT uiIn, BYTE *pbOut);
int WSAHtonl(SOCKET s, u_long hostlong, u_long *lpnetlong);
CONFIGRET CM_Query_And_Remove_SubTreeW(DEVINST dnAncestor, unknown_t pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags);
BOOL OperationEnd(unknown_t *OperationEndParams);
BOOL PFXVerifyPassword(unknown_t *pPFX, LPCWSTR szPassword, DWORD dwFlags);
BOOL Compress(COMPRESSOR_HANDLE CompressorHandle, LPCVOID UncompressedData, SIZE_T UncompressedDataSize, PVOID CompressedBuffer, SIZE_T CompressedBufferSize, PSIZE_T CompressedDataSize);
BOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR ObjectDescriptor, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ResultantDescriptor, DWORD DescriptorLength, PDWORD ReturnLength);
BOOL ExtTextOutA(HDC hdc, int X, int Y, unknown_t fuOptions, RECT *lprc, LPCSTR lpString, UINT cbCount, INT *lpDx);
int islower(int c);
HRESULT VarBoolFromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, unknown_t *pboolOut);
HRESULT CoCancelCall(DWORD dwThreadId, ULONG ulTimeout);
HRESULT SHCreateItemFromIDList(unknown_t pidl, REFIID riid, void **ppv);
HRESULT VarUI1FromUI8(ULONG64 ui64In, BYTE *pbOut);
BOOL WinHttpWriteData(HINTERNET hRequest, LPCVOID lpBuffer, DWORD dwNumberOfBytesToWrite, LPDWORD lpdwNumberOfBytesWritten);
long double atan2l(long double y, long double x);
INT WSCInstallNameSpaceEx32(LPWSTR lpszIdentifier, LPWSTR lpszPathName, DWORD dwNameSpace, DWORD dwVersion, LPGUID lpProviderId, LPBLOB lpProviderSpecific);
PCCTL_CONTEXT CertDuplicateCTLContext(PCCTL_CONTEXT pCtlContext);
BOOL EnumSystemGeoID(GEOCLASS GeoClass, GEOID ParentGeoId, GEO_ENUMPROC lpGeoEnumProc);
BOOL EnumDateFormatsExEx(DATEFMT_ENUMPROCEXEX lpDateFmtEnumProcExEx, LPCWSTR lpLocaleName, DWORD dwFlags, LPARAM lParam);
BOOL WriteFileGather(HANDLE hFile, FILE_SEGMENT_ELEMENT *aSegmentArray, DWORD nNumberOfBytesToWrite, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped);
BOOL RemoveFontMemResourceEx();
HRESULT VarTokenizeFormatString(LPOLESTR pstrFormat, LPBYTE rgbTok, int cbTok, int iFirstDay, int iFirstWeek, LCID lcid, int *pcbActual);
CONFIGRET CM_Register_Device_Interface_ExA(DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCSTR pszReference, LPSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
double remquo(double x, double y, int *pquo);
int CompareStringW(LCID Locale, DWORD dwCmpFlags, PCNZWCH lpString1, int cchCount1, PCNZWCH lpString2, int cchCount2);
float atan2f(float y, float x);
int EnumFontFamiliesW(HDC hdc, LPCWSTR lpszFamily, unknown_t lpEnumFontFamProc, LPARAM lParam);
VOID RaiseFailFastException(PEXCEPTION_RECORD pExceptionRecord, PCONTEXT pContextRecord, DWORD dwFlags);
SC_HANDLE CreateServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword);
BOOL AddPortW(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName);
USHORT QueryDepthSList(PSLIST_HEADER ListHead);
int WSCGetProviderInfo(LPGUID lpProviderId, WSC_PROVIDER_INFO_TYPE InfoType, PBYTE Info, size_t *InfoSize, DWORD Flags, LPINT lpErrno);
BOOL WinHttpSetDefaultProxyConfiguration(unknown_t *pProxyInfo);
BOOL SymSrvGetFileIndexes(PCSTR File, GUID *Id, PDWORD Val1, PDWORD Val2, DWORD Flags);
LPCSTR CertAlgIdToOID(DWORD dwAlgId);
BOOL GetCachedSigningLevel(HANDLE File, PULONG Flags, PULONG SigningLevel, PUCHAR Thumbprint, PULONG ThumbprintSize, PULONG ThumbprintAlgorithm);
LPSTR PathFindNextComponentA(LPCSTR pszPath);
LANGID SetThreadUILanguage(LANGID LangId);
HRESULT VarNot(LPVARIANT pvarIn, LPVARIANT pvarResult);
HANDLE OpenThread(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId);
BOOL CertEnumSystemStoreLocation(DWORD dwFlags, void *pvArg, PFN_CERT_ENUM_SYSTEM_STORE_LOCATION pfnEnum);
CONFIGRET CM_Register_Device_Interface_ExW(DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCWSTR pszReference, LPWSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine);
BOOL GetMenuBarInfo(HWND hwnd, LONG idObject, LONG idItem, PMENUBARINFO pmbi);
LDAPMessage * ldap_first_reference(LDAP *ld, LDAPMessage *res);
BOOL SymAddSymbol(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Name, DWORD64 Address, DWORD Size, DWORD Flags);
int EnumFontFamiliesA(HDC hdc, LPCSTR lpszFamily, unknown_t lpEnumFontFamProc, LPARAM lParam);
DWORD GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer);
int CompareStringA(LCID Locale, DWORD dwCmpFlags, PCNZCH lpString1, int cchCount1, PCNZCH lpString2, int cchCount2);
SC_HANDLE CreateServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPCSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword);
void FreeAddrInfoEx(unknown_t pAddrInfoEx);
int closesocket(SOCKET s);
BOOL AddPortA(LPSTR pName, HWND hWnd, LPSTR pMonitorName);
HRESULT RegisterScaleChangeEvent(HANDLE hEvent, DWORD_PTR *pdwCookie);
BOOL ImageList_DragShowNolock(BOOL fShow);
HRESULT VarXor(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
LPWSTR PathFindNextComponentW(LPCWSTR pszPath);
BOOL QueryServiceLockStatusA(SC_HANDLE hSCManager, unknown_t lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
ULONG UpdateTraceW(TRACEHANDLE TraceHandle, LPCWSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
BOOL SymSetSearchPathW(HANDLE hProcess, PCWSTR SearchPath);
BOOL SymEnumLines(HANDLE hProcess, ULONG64 Base, PCSTR Obj, PCSTR File, PSYM_ENUMLINES_CALLBACK EnumLinesCallback, PVOID UserContext);
DWORD GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer);
double difftime(time_t time1, time_t time0);
LDAPMessage * ldap_first_entry(LDAP *ld, LDAPMessage *res);
BOOL QueryServiceLockStatusW(SC_HANDLE hSCManager, unknown_t lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
LDAP * ldap_openW(PWSTR HostName, ULONG PortNumber);
NTSTATUS RtlLocalTimeToSystemTime(PLARGE_INTEGER LocalTime, PLARGE_INTEGER SystemTime);
float erff(float x);
void * fts_read_INODE64(void *ftsp);
ULONG UpdateTraceA(TRACEHANDLE TraceHandle, LPCSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties);
DWORD GetClassLongW(HWND hWnd, int nIndex);
double erfc(double x);
long double erfl(long double x);
ULONG ldap_delete_ext_s(LDAP *ld, const PSTR dn, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls);
int ShellMessageBoxA(HINSTANCE hAppInst, HWND hWnd, LPCSTR lpcText, LPCSTR lpcTitle, UINT fuStyle, unknown_t ...);
PSLIST_ENTRY InterlockedFlushSList(PSLIST_HEADER ListHead);
BOOL SetICMProfileA(HDC hDC, LPSTR lpFileName);
unknown_t * SafeArrayCreateVectorEx(VARTYPE vt, LONG lLbound, ULONG cElements, PVOID pvExtra);
DWORD64 SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, PMODLOAD_DATA Data, DWORD Flags);
HRESULT VarDecInt(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
ULONG ber_next_element(BerElement *pBerElement, ULONG *pLen, CHAR *opaque);
BOOL CombineTransform(unknown_t lpxformResult, unknown_t *lpxform1, unknown_t *lpxform2);
LDAP * ldap_openA(const PSTR HostName, ULONG PortNumber);
BOOL SetRect(LPRECT lprc, int xLeft, int yTop, int xRight, int yBottom);
BOOL EnumFormsW(HPRINTER hPrinter, DWORD Level, unknown_t pForm, int cbBuf, int *pcbNeeded, int *pcReturned);
int ShellMessageBoxW(HINSTANCE hAppInst, HWND hWnd, LPCWSTR lpcText, LPCWSTR lpcTitle, UINT fuStyle, unknown_t ...);
BOOL ExitWindowsEx(UINT uFlags, DWORD dwReason);
BOOL CertIsRDNAttrsInCertificateName(DWORD dwCertEncodingType, DWORD dwFlags, PCERT_NAME_BLOB pCertName, PCERT_RDN pRDN);
HANDLE OpenSemaphoreA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
BOOL ReleaseCapture();
BOOL TerminateThread(HANDLE hThread, DWORD dwExitCode);
BOOL SetICMProfileW(HDC hDC, LPWSTR lpFileName);
DWORD GetClassLongA(HWND hWnd, int nIndex);
BOOL SHRegGetBoolValueFromHKCUHKLM(PCWSTR pszKey, PCWSTR pszValue, BOOL fDefault);
BOOL CryptAcquireContextA(HCRYPTPROV *phProv, LPCSTR szContainer, LPCSTR szProvider, DWORD dwProvType, DWORD dwFlags);
BOOL GetProcessMemoryInfo(HANDLE Process, PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb);
int GetPriorityClipboardFormat(UINT *paFormatPriorityList, int cFormats);
CONFIGRET CM_Disconnect_Machine(HMACHINE hMachine);
HINSTANCE ShellExecuteA(HWND hwnd, LPCSTR lpOperation, LPCSTR lpFile, LPCSTR lpParameters, LPCSTR lpDirectory, INT nShowCmd);
BOOL EnumFormsA(HPRINTER hPrinter, DWORD Level, unknown_t pForm, int cbBuf, int *pcbNeeded, int *pcReturned);
BOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength);
PTP_TIMER CreateThreadpoolTimer(PTP_TIMER_CALLBACK pfnti, PVOID pv, PTP_CALLBACK_ENVIRON pcbe);
BOOL VirtualFreeEx(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType);
BOOL CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR szContainer, LPCWSTR szProvider, DWORD dwProvType, DWORD dwFlags);
BOOL PathMakePrettyW(LPWSTR pszPath);
HANDLE OpenSemaphoreW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
BOOL K32GetProcessMemoryInfo(HANDLE Process, PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb);
VOID WaitForThreadpoolWaitCallbacks(PTP_WAIT pwa, BOOL fCancelPendingCallbacks);
HINSTANCE ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);
float scalbnf(float x, int ex);
CONFIGRET CM_Register_Device_Driver_Ex(DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
INT GetNameInfoW(SOCKADDR *pSockaddr, socklen_t SockaddrLength, PWCHAR pNodeBuffer, DWORD NodeBufferSize, PWCHAR pServiceBuffer, DWORD ServiceBufferSize, INT Flags);
BOOL BackupWrite(HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, BOOL bAbort, BOOL bProcessSecurity, LPVOID *lpContext);
BOOL AbortPrinter();
long double scalbnl(long double x, int ex);
BOOL QueryServiceConfigW(SC_HANDLE hService, unknown_t lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
HRESULT QueryHitPoint(DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc, LONG lCloseHint, DWORD *pHitResult);
BOOL PathMakePrettyA(LPSTR pszPath);
BOOL CryptSignAndEncryptMessage(PCRYPT_SIGN_MESSAGE_PARA pSignPara, PCRYPT_ENCRYPT_MESSAGE_PARA pEncryptPara, DWORD cRecipientCert, PCCERT_CONTEXT *rgpRecipientCert, BYTE *pbToBeSignedAndEncrypted, DWORD cbToBeSignedAndEncrypted, BYTE *pbSignedAndEncryptedBlob, DWORD *pcbSignedAndEncryptedBlob);
void CoTaskMemFree(LPVOID pv);
int vfwscanf(FILE *stream, wchar_t *format, va_list arg);
BOOLEAN EventProviderEnabled(REGHANDLE RegHandle, UCHAR Level, ULONGLONG Keyword);
wint_t getwc(FILE *stream);
BOOL SetMenuDefaultItem(HMENU hMenu, UINT uItem, UINT fByPos);
HANDLE OpenBackupEventLogW(LPCWSTR lpUNCServerName, LPCWSTR lpFileName);
BOOL FlatSB_GetScrollRange(HWND ARG_0, int code, LPINT ARG_2, LPINT ARG_3);
BOOL QueryServiceConfigA(SC_HANDLE hService, unknown_t lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
int GetSystemMetricsForDpi(int nIndex, UINT dpi);
BOOL GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime);
HICON CreateIconIndirect(PICONINFO piconinfo);
BOOL SHUnlockShared(void *pvData);
BOOL CryptSIPPutSignedDataMsg(unknown_t *pSubjectInfo, DWORD dwEncodingType, DWORD *pdwIndex, DWORD cbSignedDataMsg, BYTE *pbSignedDataMsg);
HRESULT CoGetContextToken(ULONG_PTR *pToken);
CONFIGRET CM_Get_Device_Interface_Property_Keys_ExW(LPCWSTR pszDeviceInterface, unknown_t *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags, HMACHINE hMachine);
BOOL RemoveFontResourceExA(LPCSTR lpFileName, unknown_t fl, unknown_t *pdv);
BOOL PFXExportCertStoreEx(HCERTSTORE hStore, unknown_t *pPFX, LPCWSTR szPassword, void *pvPara, DWORD dwFlags);
BOOL SymRegisterFunctionEntryCallback(HANDLE hProcess, PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction, PVOID UserContext);
HINTERNET WinHttpOpenRequest(HINTERNET hConnect, LPCWSTR pwszVerb, LPCWSTR pwszObjectName, LPCWSTR pwszVersion, LPCWSTR pwszReferrer, LPCWSTR *ppwszAcceptTypes, DWORD dwFlags);
HWND GetCapture();
size_t wcsxfrm(wchar_t *s1, wchar_t *s2, size_t n);
float fmodf(float x, float y);
int SHFormatDateTimeW(FILETIME *pft, DWORD *pdwFlags, LPWSTR pszBuf, UINT cchBuf);
BOOL SymEnumSymbolsW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
int shutdown(SOCKET s, int how);
long GetPixelFormat();
BOOL ReplaceFileA(LPCSTR lpReplacedFileName, LPCSTR lpReplacementFileName, LPCSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved);
BOOL RemoveFontResourceExW(LPCWSTR lpFileName, unknown_t fl, unknown_t *pdv);
LPWSTR lstrcpynW(LPWSTR lpString1, LPCWSTR lpString2, int iMaxLength);
long double fmodl(long double x, long double y);
int lstrlenW(LPCWSTR lpString);
HANDLE OpenBackupEventLogA(LPCSTR lpUNCServerName, LPCSTR lpFileName);
BOOL ReplaceFileW(LPCWSTR lpReplacedFileName, LPCWSTR lpReplacementFileName, LPCWSTR lpBackupFileName, DWORD dwReplaceFlags, LPVOID lpExclude, LPVOID lpReserved);
LONG CertVerifyCRLTimeValidity(LPFILETIME pTimeToVerify, PCRL_INFO pCrlInfo);
LPSTR lstrcpynA(LPSTR lpString1, LPCSTR lpString2, int iMaxLength);
BOOL ReplyMessage(LRESULT lResult);
BOOL MoveFileExA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags);
int SHFormatDateTimeA(FILETIME *pft, DWORD *pdwFlags, LPSTR pszBuf, UINT cchBuf);
BOOL BackupRead(HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, BOOL bAbort, BOOL bProcessSecurity, LPVOID *lpContext);
int lstrlenA(LPCSTR lpString);
void * mmap(void *addr, size_t length, int prot, int flags, int fd, size_t offset);
BOOL MoveFileExW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags);
HRESULT CoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases);
long double frexpl(long double value, int *exp);
CONFIGRET CM_Get_Device_ID_ListA(PCSTR pszFilter, PZZSTR Buffer, ULONG BufferLen, ULONG ulFlags);
char * mktemp(char *template);
CONFIGRET CM_Get_Parent_Ex(unknown_t pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
BOOL GetProcessInformation(HANDLE hProcess, PROCESS_INFORMATION_CLASS ProcessInformationClass, LPVOID ProcessInformation, DWORD ProcessInformationSize);
DWORD GetEnhMetaFileBits(HENHMETAFILE hemf, UINT cbBuffer, LPBYTE lpbBuffer);
BOOL CertGetCTLContextProperty(PCCTL_CONTEXT pCtlContext, DWORD dwPropId, void *pvData, DWORD *pcbData);
LDAP * ldap_sslinit(PSTR HostName, ULONG PortNumber, int secure);
BOOLEAN GetPwrCapabilities(PSYSTEM_POWER_CAPABILITIES lpspc);
NTSTATUS BCryptHash(BCRYPT_ALG_HANDLE hAlgorithm, PUCHAR pbSecret, ULONG cbSecret, PUCHAR pbInput, ULONG cbInput, PUCHAR pbOutput, ULONG cbOutput);
float frexpf(float value, int *exp);
INT GetAddrInfoExW(PCWSTR pName, PCWSTR pServiceName, DWORD dwNameSpace, LPGUID lpNspId, unknown_t *hints, unknown_t *ppResult, struct timeval *timeout, LPOVERLAPPED lpOverlapped, unknown_t lpCompletionRoutine, LPHANDLE lpHandle);
PLDAPSearch ldap_search_init_page(PLDAP ExternalHandle, const PSTR DistinguishedName, ULONG ScopeOfSearch, const PSTR SearchFilter, PZPSTR AttributeList, ULONG AttributesOnly, unknown_t *ServerControls, unknown_t *ClientControls, ULONG PageTimeLimit, ULONG TotalSizeLimit, unknown_t *SortKeys);
BOOL FreeEnvironmentStringsA(LPCH penv);
DWORD WinHttpWebSocketReceive(HINTERNET hWebSocket, PVOID pvBuffer, DWORD dwBufferLength, DWORD *pdwBytesRead, WINHTTP_WEB_SOCKET_BUFFER_TYPE *peBufferType);
HRESULT PropVariantClear(unknown_t *pvar);
BOOL PatBlt(HDC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, unknown_t dwRop);
INT inet_pton(INT Family, PCSTR pszAddrString, PVOID pAddrBuf);
CONFIGRET CM_Get_Device_ID_ListW(PCWSTR pszFilter, PZZWSTR Buffer, ULONG BufferLen, ULONG ulFlags);
INT VariantTimeToDosDateTime(DOUBLE vtime, USHORT *pwDosDate, USHORT *pwDosTime);
CONFIGRET CM_Uninstall_DevNode_Ex(DEVNODE dnDevInst, ULONG ulFlags, HMACHINE hMachine);
BOOL GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode);
void CoUninitialize();
PCCRL_CONTEXT CertEnumCRLsInStore(HCERTSTORE hCertStore, PCCRL_CONTEXT pPrevCrlContext);
INT GetAddrInfoExA(PCSTR pName, PCSTR pServiceName, DWORD dwNameSpace, LPGUID lpNspId, unknown_t *hints, unknown_t *ppResult, struct timeval *timeout, LPOVERLAPPED lpOverlapped, unknown_t lpCompletionRoutine, LPHANDLE lpNameHandle);
CONFIGRET CM_Get_Sibling_Ex(unknown_t pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine);
BOOL CertSetEnhancedKeyUsage(PCCERT_CONTEXT pCertContext, PCERT_ENHKEY_USAGE pUsage);
int OffsetRgn(HRGN HRGN, int nXOffset, int nYOffset);
BOOL ImpersonateAnonymousToken(HANDLE ThreadHandle);
BOOL FreeEnvironmentStringsW(LPWCH penv);
BOOL SetConsoleCP(UINT wCodePageID);
SECURITY_STATUS NCryptEnumStorageProviders(DWORD *pdwProviderCount, unknown_t **ppProviderList, DWORD dwFlags);
HRESULT VarNeg(LPVARIANT pvarIn, LPVARIANT pvarResult);
BOOL CredProtectW(BOOL fAsSelf, LPWSTR pszCredentials, DWORD cchCredentials, LPWSTR pszProtectedCredentials, DWORD *pcchMaxChars, CRED_PROTECTION_TYPE *ProtectionType);
WINHTTP_STATUS_CALLBACK WinHttpSetStatusCallback(HINTERNET hInternet, WINHTTP_STATUS_CALLBACK lpfnInternetCallback, DWORD dwNotificationFlags, DWORD_PTR dwReserved);
HANDLE CreateBoundaryDescriptorA(LPCSTR Name, ULONG Flags);
int GetTextCharset(HDC hdc);
BOOL FindNextFileNameW(HANDLE hFindStream, LPDWORD StringLength, PWSTR LinkName);
BOOL GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation);
BOOL CertSetCTLContextProperty(PCCTL_CONTEXT pCtlContext, DWORD dwPropId, DWORD dwFlags, const void *pvData);
LSTATUS RegLoadAppKeyA(LPCSTR lpFile, PHKEY phkResult, REGSAM samDesired, DWORD dwOptions, DWORD Reserved);
BOOL SetSearchPathMode(DWORD Flags);
unknown_t * gethostbyaddr(const char *addr, int len, int type);
NTSTATUS BCryptDestroySecret(BCRYPT_SECRET_HANDLE hSecret);
BOOL SymGetSymNext64(HANDLE hProcess, PIMAGEHLP_SYMBOL64 Symbol);
HANDLE CreateBoundaryDescriptorW(LPCWSTR Name, ULONG Flags);
BOOL CredProtectA(BOOL fAsSelf, LPSTR pszCredentials, DWORD cchCredentials, LPSTR pszProtectedCredentials, DWORD *pcchMaxChars, CRED_PROTECTION_TYPE *ProtectionType);
HRESULT VarI1FromUI2(USHORT uiIn, CHAR *pcOut);
ULONG ldap_control_free(LDAPControlA *Control);
UINT ResetWriteWatch(LPVOID lpBaseAddress, SIZE_T dwRegionSize);
BOOL CertIsWeakHash(DWORD dwHashUseType, LPCWSTR pwszCNGHashAlgid, DWORD dwChainFlags, PCCERT_CHAIN_CONTEXT pSignerChainContext, LPFILETIME pTimeStamp, LPCWSTR pwszFileName);
HRESULT CoCreateStandardMalloc(DWORD memctx, unknown_t **ppMalloc);
ULONG EnableTrace(ULONG Enable, ULONG EnableFlag, ULONG EnableLevel, LPCGUID ControlGuid, TRACEHANDLE TraceHandle);
HRESULT VarI1FromUI1(BYTE bIn, CHAR *pcOut);
LSTATUS RegLoadAppKeyW(LPCWSTR lpFile, PHKEY phkResult, REGSAM samDesired, DWORD dwOptions, DWORD Reserved);
BOOL Wow64DisableWow64FsRedirection(PVOID *OldValue);
void * fts_open_INODE64(const char *path_argv, int options, void *compar, void *ftsen$INODE64t);
HRESULT VarI1FromUI4(ULONG ulIn, CHAR *pcOut);
BOOL IsChild(HWND hWndParent, HWND hWnd);
VOID ReleaseActCtx(HANDLE hActCtx);
long long llrintf(float x);
DWORD GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSize);
HRESULT VarI1FromUI8(ULONG64 i64In, CHAR *pcOut);
HCERT_SERVER_OCSP_RESPONSE CertOpenServerOcspResponse(PCCERT_CHAIN_CONTEXT pChainContext, DWORD dwFlags, PCERT_SERVER_OCSP_RESPONSE_OPEN_PARA pOpenPara);
BOOL GetNLSVersion(NLS_FUNCTION Function, LCID Locale, LPNLSVERSIONINFO lpVersionInformation);
long long llrintl(long double x);
BOOL SetFileBandwidthReservation(HANDLE hFile, DWORD nPeriodMilliseconds, DWORD nBytesPerPeriod, BOOL bDiscardable, LPDWORD lpTransferSize, LPDWORD lpNumOutstandingRequests);
BOOL OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle);
LONG_PTR GetWindowLongPtrA(HWND hWnd, int nIndex);
FILE * fopen(const char *filename, const char *mode);
BOOL AddSecureMemoryCacheCallback(PSECURE_MEMORY_CACHE_CALLBACK pfnCallBack);
BOOL SHIsLowMemoryMachine(DWORD dwType);
INT ber_printf(BerElement *pBerElement, PSTR fmt, unknown_t ...);
int GetCurrencyFormatW(LCID Locale, DWORD dwFlags, LPCWSTR lpValue, unknown_t *lpFormat, LPWSTR lpCurrencyStr, int cchCurrency);
LPVOID TlsGetValue(DWORD dwTlsIndex);
BOOL ScrollConsoleScreenBufferW(HANDLE hConsoleOutput, SMALL_RECT *lpScrollRectangle, SMALL_RECT *lpClipRectangle, COORD dwDestinationOrigin, CHAR_INFO *lpFill);
BOOL ImageList_DragEnter(HWND hwndLock, int x, int y);
DWORD GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize);
BOOL InstallELAMCertificateInfo(HANDLE ELAMFile);
BOOL CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL SetConsoleWindowInfo(HANDLE hConsoleOutput, BOOL bAbsolute, SMALL_RECT *lpConsoleWindow);
HDC CreateEnhMetaFileW(HDC hdcRef, LPCWSTR lpFilename, RECT *lpRect, LPCWSTR lpDescription);
LONG_PTR GetWindowLongPtrW(HWND hWnd, int nIndex);
BOOL CryptSetProviderA(LPCSTR pszProvName, DWORD dwProvType);
ULONG ldap_parse_sort_controlA(PLDAP ExternalHandle, PLDAPControlA *Control, ULONG *Result, PCHAR *Attribute);
BOOL ScrollConsoleScreenBufferA(HANDLE hConsoleOutput, SMALL_RECT *lpScrollRectangle, SMALL_RECT *lpClipRectangle, COORD dwDestinationOrigin, CHAR_INFO *lpFill);
DLL_DIRECTORY_COOKIE AddDllDirectory(PCWSTR NewDirectory);
HDC CreateEnhMetaFileA(HDC hdcRef, LPCSTR lpFilename, RECT *lpRect, LPCSTR lpDescription);
LSTATUS RegSetValueW(HKEY hKey, LPCWSTR lpSubKey, DWORD dwType, LPCWSTR lpData, DWORD cbData);
int GetCurrencyFormatA(LCID Locale, DWORD dwFlags, LPCSTR lpValue, unknown_t *lpFormat, LPSTR lpCurrencyStr, int cchCurrency);
int listen(SOCKET s, int backlog);
DEP_SYSTEM_POLICY_TYPE GetSystemDEPPolicy();
BOOL CreateDirectoryW(LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL GetNLSVersionEx(NLS_FUNCTION function, LPCWSTR lpLocaleName, LPNLSVERSIONINFOEX lpVersionInformation);
BOOL SetPriorityClass(HANDLE hProcess, DWORD dwPriorityClass);
CONFIGRET CM_Open_Class_Key_ExW(LPGUID ClassGuid, LPCWSTR pszClassName, REGSAM samDesired, unknown_t Disposition, PHKEY phkClass, ULONG ulFlags, HMACHINE hMachine);
BOOL CryptSetProviderW(LPCWSTR pszProvName, DWORD dwProvType);
ULONG ldap_parse_sort_controlW(PLDAP ExternalHandle, PLDAPControlW *Control, ULONG *Result, PWCHAR *Attribute);
uid_t geteuid();
CONFIGRET CM_Set_DevNode_Problem(DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags);
BOOL ImpersonateLoggedOnUser(HANDLE hToken);
int SetScrollInfo(HWND hwnd, int nBar, LPCSCROLLINFO lpsi, BOOL redraw);
LSTATUS RegSetValueA(HKEY hKey, LPCSTR lpSubKey, DWORD dwType, LPCSTR lpData, DWORD cbData);
LCID LocaleNameToLCID(LPCWSTR lpName, DWORD dwFlags);
HRESULT VarI1FromI4(LONG lIn, CHAR *pcOut);
SIZE_T GetLargePageMinimum();
HRESULT VarI1FromI2(SHORT uiIn, CHAR *pcOut);
double scalbln(double x, long ex);
BOOL EnumerateLoadedModules64(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, PVOID UserContext);
CONFIGRET CM_Open_Class_Key_ExA(LPGUID ClassGuid, LPCSTR pszClassName, REGSAM samDesired, unknown_t Disposition, PHKEY phkClass, ULONG ulFlags, HMACHINE hMachine);
BOOL WinHttpQueryHeaders(HINTERNET hRequest, DWORD dwInfoLevel, LPCWSTR pwszName, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex);
CONFIGRET CM_Query_Remove_SubTree_Ex(DEVINST dnAncestor, ULONG ulFlags, HMACHINE hMachine);
HRESULT VarUI8FromCy(unknown_t cyIn, ULONG64 *pi64Out);
DWORD SetThreadIdealProcessor(HANDLE hThread, DWORD dwIdealProcessor);
BOOL IsSystemResumeAutomatic();
BOOL CertVerifyCertificateChainPolicy(LPCSTR pszPolicyOID, PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara, PCERT_CHAIN_POLICY_STATUS pPolicyStatus);
BOOL GetWindowExtEx(HDC hdc, LPSIZE lpSize);
HRESULT VarI1FromI8(LONG64 i64In, CHAR *pcOut);
HICON CopyIcon(HICON hIcon);
BOOL SetKernelObjectSecurity(HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor);
BOOL ReportEventA(HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData);
CONFIGRET CM_Get_Resource_Conflict_Count(unknown_t clConflictList, PULONG pulCount);
BOOL GetThreadContext(HANDLE hThread, LPCONTEXT lpContext);
BOOL WriteProfileStringA(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString);
int GetTimeFormatEx(LPCWSTR lpLocaleName, DWORD dwFlags, SYSTEMTIME *lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, int cchTime);
HANDLE CreateRemoteThreadEx(HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, LPDWORD lpThreadId);
BOOL ReportEventW(HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR *lpStrings, LPVOID lpRawData);
CONFIGRET CM_Free_Res_Des_Handle(RES_DES rdResDes);
HRESULT CoWaitForMultipleObjects(DWORD dwFlags, DWORD dwTimeout, ULONG cHandles, HANDLE *pHandles, LPDWORD lpdwindex);
BOOL ZombifyActCtx(HANDLE hActCtx);
BOOL WriteProfileStringW(LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString);
LPWSTR PathBuildRootW(LPWSTR pszRoot, int iDrive);
VOID SetThreadpoolWait(PTP_WAIT pwa, HANDLE h, PFILETIME pftTimeout);
BOOL GetNumaNodeNumberFromHandle(HANDLE hFile, PUSHORT NodeNumber);
HRESULT CoReleaseMarshalData(LPSTREAM pStm);
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
HANDLE CopyImage(HANDLE h, UINT type, int cx, int cy, UINT flags);
int WSCSetProviderInfo32(LPGUID lpProviderId, WSC_PROVIDER_INFO_TYPE InfoType, PBYTE Info, size_t InfoSize, DWORD Flags, LPINT lpErrno);
LPSTR PathBuildRootA(LPSTR pszRoot, int iDrive);
NTSTATUS BCryptUnregisterConfigChangeNotify(PRKEVENT pEvent);
BOOL SetProcessShutdownParameters(DWORD dwLevel, DWORD dwFlags);
HRGN PathToRegion();
long GetPrinterDataA(HPRINTER hPrinter, LPSTR pValueName, unknown_t *pType, LPBYTE pData, int nSize, int *pcbNeeded);
BSTR SysAllocString(unknown_t *psz);
HRESULT VarCat(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
PSLIST_ENTRY InterlockedPushEntrySList(PSLIST_HEADER ListHead, PSLIST_ENTRY ListEntry);
BOOL SymEnumerateSymbols64(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback, PVOID UserContext);
BOOL AddAccessAllowedObjectAce(PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID *ObjectTypeGuid, GUID *InheritedObjectTypeGuid, PSID pSid);
double acos(double x);
BOOL StrToInt64ExA(PCSTR pszString, unknown_t dwFlags, LONGLONG *pllRet);
NTSTATUS NtWaitForSingleObject(HANDLE Handle, BOOLEAN Alertable, PLARGE_INTEGER Timeout);
LRESULT SendDlgItemMessageA(HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL ResetPrinterW(HPRINTER hPrinter, unknown_t pDefault);
long GetPrinterDataW(HPRINTER hPrinter, LPWSTR pValueName, unknown_t *pType, LPBYTE pData, int nSize, int *pcbNeeded);
long double strtold(const char *str, char **endptr);
uintmax_t wcstoumax(wchar_t *nptr, wchar_t **endptr, int base);
BOOL WinHttpGetIEProxyConfigForCurrentUser(unknown_t *pProxyConfig);
BOOL CryptDecryptMessage(PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara, BYTE *pbEncryptedBlob, DWORD cbEncryptedBlob, BYTE *pbDecrypted, DWORD *pcbDecrypted, PCCERT_CONTEXT *ppXchgCert);
BOOL StrToInt64ExW(PCWSTR pszString, unknown_t dwFlags, LONGLONG *pllRet);
LSTATUS SHQueryValueExA(HKEY hkey, LPCSTR pszValue, DWORD *pdwReserved, DWORD *pdwType, void *pvData, DWORD *pcbData);
BOOLEAN RtlDeleteFunctionTable(PRUNTIME_FUNCTION FunctionTable);
long long strtoll(const char *str, char **endptr, int base);
UINT GlobalFlags(HGLOBAL hMem);
int kill(pid_t pid, int sig);
HRESULT VarMul(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
HANDLE FindDebugInfoFile(PCSTR FileName, PCSTR SymbolPath, PSTR DebugFilePath);
BOOL CreateProcessWithLogonW(LPCWSTR lpUsername, LPCWSTR lpDomain, LPCWSTR lpPassword, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation);
LRESULT SendDlgItemMessageW(HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL ResetPrinterA(HPRINTER hPrinter, unknown_t pDefault);
HENHMETAFILE CloseEnhMetaFile();
BOOL SymEnumSourceFilesW(HANDLE hProcess, ULONG64 ModBase, PCWSTR Mask, PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles, PVOID UserContext);
LSTATUS SHQueryValueExW(HKEY hkey, LPCWSTR pszValue, DWORD *pdwReserved, DWORD *pdwType, void *pvData, DWORD *pcbData);
BOOL EnableMenuItem(HMENU hMenu, UINT uIDEnableItem, UINT uEnable);
BOOL LockWindowUpdate(HWND hWndLock);
BOOL SetServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor);
long double sinhl(long double x);
VOID CertAddRefServerOcspResponseContext(PCCERT_SERVER_OCSP_RESPONSE_CONTEXT pServerOcspResponseContext);
DWORD GetProcessHeaps(DWORD NumberOfHeaps, PHANDLE ProcessHeaps);
BOOL CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr, DWORD dwFlags);
CONFIGRET CM_Get_Log_Conf_Priority(unknown_t lcLogConf, unknown_t pPriority, ULONG ulFlags);
HRESULT LoadTypeLib(LPCOLESTR szFile, unknown_t **pptlib);
ULONG ldap_search_ext(LDAP *ld, PSTR base, ULONG scope, PSTR filter, PZPSTR attrs, ULONG attrsonly, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG TimeLimit, ULONG SizeLimit, ULONG *MessageNumber);
float sinhf(float x);
HANDLE FindFirstFileTransactedW(LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags, HANDLE hTransaction);
HRESULT PathMatchSpecExA(LPCSTR pszFile, LPCSTR pszSpec, DWORD dwFlags);
HRESULT VarMonthName(int iMonth, int fAbbrev, ULONG dwFlags, BSTR *pbstrOut);
int GetScrollPos(HWND hWnd, int nBar);
BOOL SetAclInformation(PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass);
BOOL GetEventLogInformation(HANDLE hEventLog, DWORD dwInfoLevel, LPVOID lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
HANDLE FindFirstFileTransactedA(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags, HANDLE hTransaction);
BOOL SetLayeredWindowAttributes(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);
HRESULT DispGetIDsOfNames(unknown_t *ptinfo, LPOLESTR *rgszNames, UINT cNames, unknown_t *rgdispid);
BOOL GetCaretPos(LPPOINT lpPoint);
BOOL SetDeviceGammaRamp(HDC hDC, LPVOID lpRamp);
BOOL GetCurrentInputMessageSource(unknown_t *inputMessageSource);
INT WSALookupServiceBeginW(LPWSAQUERYSETW lpqsRestrictions, DWORD dwControlFlags, LPHANDLE lphLookup);
HRESULT PathMatchSpecExW(LPCWSTR pszFile, LPCWSTR pszSpec, DWORD dwFlags);
wchar_t * wcsrchr(wchar_t *s, wchar_t c);
DWORD GetFullPathNameTransactedA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart, HANDLE hTransaction);
LSTATUS RegDeleteValueA(HKEY hKey, LPCSTR lpValueName);
BOOL SetConsoleCursorPosition(HANDLE hConsoleOutput, COORD dwCursorPosition);
HRESULT VarI1FromCy(unknown_t cyIn, CHAR *pcOut);
INT WSALookupServiceBeginA(LPWSAQUERYSETA lpqsRestrictions, DWORD dwControlFlags, LPHANDLE lphLookup);
BOOL IsIconic(HWND hWnd);
ULONG ldap_set_optionW(LDAP *ld, int option, const void *invalue);
BOOL EnableScrollBar(HWND hWnd, UINT wSBflags, UINT wArrows);
HRESULT UrlUnescapeW(PWSTR pszUrl, PWSTR pszUnescaped, DWORD *pcchUnescaped, DWORD dwFlags);
DWORD GetFullPathNameTransactedW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart, HANDLE hTransaction);
LSTATUS RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName);
LPVOID HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes);
BOOL SymGetSearchPathW(HANDLE hProcess, PWSTR SearchPath, DWORD SearchPathLength);
BOOL GetCurrentPositionEx(HDC hdc, LPPOINT lpPoint);
CONFIGRET CM_Get_Next_Log_Conf_Ex(unknown_t plcLogConf, unknown_t lcLogConf, ULONG ulFlags, HMACHINE hMachine);
BOOL EnumSystemLocalesEx(LOCALE_ENUMPROCEX lpLocaleEnumProcEx, DWORD dwFlags, LPARAM lParam, LPVOID lpReserved);
VOID DebugBreak();
HRESULT UrlUnescapeA(PSTR pszUrl, PSTR pszUnescaped, DWORD *pcchUnescaped, DWORD dwFlags);
ULONG ldap_parse_page_control(PLDAP ExternalHandle, PLDAPControlA *ServerControls, ULONG *TotalCount, struct berval **Cookie);
BOOL CallMsgFilterW(LPMSG lpMsg, int nCode);
BOOL CreateDirectoryTransactedA(LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes, HANDLE hTransaction);
DWORD GetFileVersionInfoSizeA(LPCSTR lptstrFilename, LPDWORD lpdwHandle);
LSTATUS SHRegWriteUSValueW(HUSKEY hUSKey, LPCWSTR pwzValue, DWORD dwType, const void *pvData, DWORD cbData, DWORD dwFlags);
void SafeArrayReleaseData(PVOID pData);
BOOL GetProcessIoCounters(HANDLE hProcess, PIO_COUNTERS lpIoCounters);
long SHGlobalCounterDecrement(unknown_t id);
double fmod(double x, double y);
BOOL PathRemoveFileSpecA(LPSTR pszPath);
UINT LocalFlags(HLOCAL hMem);
double scalbn(double x, int ex);
BOOL LookupPrivilegeDisplayNameA(LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId);
PCHAR SymGetHomeDirectory(DWORD type, PSTR dir, size_t size);
void error(int status, int errname, char *format);
UINT GetRawInputDeviceList(PRAWINPUTDEVICELIST pRawInputDeviceList, PUINT puiNumDevices, UINT cbSize);
BOOL IsDialogMessageW(HWND hDlg, LPMSG lpMsg);
BOOL CreateDirectoryTransactedW(LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes, HANDLE hTransaction);
HRESULT CoRegisterChannelHook(REFGUID ExtensionUuid, unknown_t *pChannelHook);
BOOL GetThreadIdealProcessorEx(HANDLE hThread, PPROCESSOR_NUMBER lpIdealProcessor);
DWORD GetFileVersionInfoSizeW(LPCWSTR lptstrFilename, LPDWORD lpdwHandle);
BOOL SetProcessDEPPolicy(DWORD dwFlags);
HINTERNET WinHttpOpen(LPCWSTR pszAgentW, DWORD dwAccessType, LPCWSTR pszProxyW, LPCWSTR pszProxyBypassW, DWORD dwFlags);
struct tm * localtime(time_t *timer);
int GetGeoInfoEx(PWSTR location, GEOTYPE geoType, PWSTR geoData, int geoDataCount);
BOOL CallMsgFilterA(LPMSG lpMsg, int nCode);
wint_t ungetwc(wint_t c, FILE *stream);
BOOL PathRemoveFileSpecW(LPWSTR pszPath);
HRESULT VarR4FromStr(LPCOLESTR strIn, LCID lcid, ULONG dwFlags, FLOAT *pfltOut);
BOOL LookupPrivilegeDisplayNameW(LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName, LPDWORD cchDisplayName, LPDWORD lpLanguageId);
int StrCmpICA(LPCSTR pszStr1, LPCSTR pszStr2);
LSTATUS SHRegWriteUSValueA(HUSKEY hUSKey, LPCSTR pszValue, DWORD dwType, const void *pvData, DWORD cbData, DWORD dwFlags);
BOOL SetMessageWaitingIndicator(HANDLE hMsgIndicator, ULONG ulMsgCount);
HRESULT IUnknown_SetSite(IUnknown *punk, IUnknown *punkSite);
UINT GetDpiForSystem();
int TranslateAcceleratorW(HWND hWnd, HACCEL hAccTable, LPMSG lpMsg);
double log1p(double x);
BOOL IsDialogMessageA(HWND hDlg, LPMSG lpMsg);
DWORD FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, va_list *Arguments);
BOOL GetThreadInformation(HANDLE hThread, THREAD_INFORMATION_CLASS ThreadInformationClass, LPVOID ThreadInformation, DWORD ThreadInformationSize);
CONFIGRET CM_Get_Device_Interface_PropertyW(LPCWSTR pszDeviceInterface, unknown_t *PropertyKey, unknown_t *PropertyType, PBYTE PropertyBuffer, PULONG PropertyBufferSize, ULONG ulFlags);
int StrCmpICW(LPCWSTR pszStr1, LPCWSTR pszStr2);
HFONT CreateFontW(int nHeight, int nWidth, int nEscapement, int nOrientation, int fnWeight, DWORD fdwItalic, DWORD fdwUnderline, DWORD fdwStrikeOut, DWORD fdwCharSet, DWORD fdwOutputPrecision, DWORD fdwClipPrecision, DWORD fdwQuality, DWORD fdwPitchAndFamily, LPCWSTR lpszFace);
BOOL CloseDecompressor(DECOMPRESSOR_HANDLE DecompressorHandle);
HANDLE OpenEventW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
DWORD64 SymGetModuleBase64(HANDLE hProcess, DWORD64 qwAddr);
DWORD FormatMessageW(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, va_list *Arguments);
BOOL AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach);
LSTATUS RegConnectRegistryW(LPCWSTR lpMachineName, HKEY hKey, PHKEY phkResult);
int TranslateAcceleratorA(HWND hWnd, HACCEL hAccTable, LPMSG lpMsg);
NTSTATUS BCryptEnumRegisteredProviders(ULONG *pcbBuffer, PCRYPT_PROVIDERS *ppBuffer);
DWORD InitiateShutdownA(LPSTR lpMachineName, LPSTR lpMessage, DWORD dwGracePeriod, DWORD dwShutdownFlags, DWORD dwReason);
BOOL CryptExportKey(HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen);
ULONG ldap_startup(unknown_t version, HANDLE *Instance);
HRESULT GetApplicationRecoveryCallback(HANDLE hProcess, APPLICATION_RECOVERY_CALLBACK *pRecoveryCallback, PVOID *ppvParameter, PDWORD pdwPingInterval, PDWORD pdwFlags);
wchar_t * wcstok(wchar_t *s1, wchar_t *s2, wchar_t **ptr);
HFONT CreateFontA(int nHeight, int nWidth, int nEscapement, int nOrientation, int fnWeight, DWORD fdwItalic, DWORD fdwUnderline, DWORD fdwStrikeOut, DWORD fdwCharSet, DWORD fdwOutputPrecision, DWORD fdwClipPrecision, DWORD fdwQuality, DWORD fdwPitchAndFamily, LPCSTR lpszFace);
BOOL TranslateMDISysAccel(HWND hWndClient, LPMSG lpMsg);
long wcstol(wchar_t *nptr, wchar_t **endptr, int base);
DWORD InitiateShutdownW(LPWSTR lpMachineName, LPWSTR lpMessage, DWORD dwGracePeriod, DWORD dwShutdownFlags, DWORD dwReason);
HANDLE OpenEventA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
void warnc(const char *format, int opt);
LSTATUS SHRegGetPathW(HKEY hKey, LPCWSTR pcszSubKey, LPCWSTR pcszValue, LPWSTR pszPath, DWORD dwFlags);
BOOL GetPointerDevices(UINT32 *deviceCount, unknown_t *pointerDevices);
BOOL SetProcessWindowStation(HWINSTA hWinSta);
double wcstod(wchar_t *nptr, wchar_t **endptr);
LSTATUS RegSaveKeyA(HKEY hKey, LPCSTR lpFile, const LPSECURITY_ATTRIBUTES lpSecurityAttributes);
float wcstof(wchar_t *nptr, wchar_t **endptr);
HRESULT VarUI8FromBool(unknown_t boolIn, ULONG64 *pi64Out);
LSTATUS RegConnectRegistryA(LPCSTR lpMachineName, HKEY hKey, PHKEY phkResult);
double fma(double x, double y, double z);
HRESULT VarCyInt(unknown_t cyIn, unknown_t pcyResult);
HRESULT VarFormatFromTokens(LPVARIANT pvarIn, LPOLESTR pstrFormat, LPBYTE pbTokCur, ULONG dwFlags, BSTR *pbstrOut, LCID lcid);
HRESULT VarUI2FromR8(DOUBLE dblIn, USHORT *puiOut);
HRESULT CoDisconnectContext(DWORD dwTimeout);
BOOL GetWindowDisplayAffinity(HWND hWnd, DWORD *pdwAffinity);
HRESULT QueryPathOfRegTypeLib(REFGUID guid, USHORT wMaj, USHORT wMin, LCID lcid, LPBSTR lpbstrPathName);
void warnx(const char *format);
BOOL TransactNamedPipe(HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped);
BOOL GetOsManufacturingMode(PBOOL pbEnabled);
double fmin(double x, double y);
void * bsearch(const void *key, const void *base, size_t nmemb, size_t size, void *compar);
VOID GetStartupInfoW(LPSTARTUPINFOW lpStartupInfo);
WORD CM_Get_Version_Ex(HMACHINE hMachine);
BOOLEAN CreateSymbolicLinkA(LPCSTR lpSymlinkFileName, LPCSTR lpTargetFileName, DWORD dwFlags);
BOOL CertRegisterPhysicalStore(const void *pvSystemStore, DWORD dwFlags, LPCWSTR pwszStoreName, PCERT_PHYSICAL_STORE_INFO pStoreInfo, void *pvReserved);
LSTATUS SHRegGetPathA(HKEY hKey, LPCSTR pcszSubKey, LPCSTR pcszValue, LPSTR pszPath, DWORD dwFlags);
HRESULT CoImpersonateClient();
HRESULT VarUI2FromR4(FLOAT fltIn, USHORT *puiOut);
LONG CryptGetMessageSignerCount(DWORD dwMsgEncodingType, BYTE *pbSignedBlob, DWORD cbSignedBlob);
BOOL SymInitializeW(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeProcess);
LSTATUS RegSaveKeyW(HKEY hKey, LPCWSTR lpFile, const LPSECURITY_ATTRIBUTES lpSecurityAttributes);
wint_t putwc(wchar_t c, FILE *stream);
HRESULT PathAllocCombine(PCWSTR pszPathIn, PCWSTR pszMore, ULONG dwFlags, PWSTR *ppszPathOut);
VOID GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo);
BOOL FloodFill(HDC hdc, int nXStart, int nYStart, COLORREF crFill);
BOOL CertIsValidCRLForCertificate(PCCERT_CONTEXT pCert, PCCRL_CONTEXT pCrl, DWORD dwFlags, void *pvReserved);
HANDLE FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData);
long SetPrinterDataW(HPRINTER hPrinter, LPWSTR pValueName, unknown_t Type, LPBYTE pData, int cbData);
BOOLEAN CreateSymbolicLinkW(LPCWSTR lpSymlinkFileName, LPCWSTR lpTargetFileName, DWORD dwFlags);
double log10(double x);
int __tolower(int c);
HRESULT GetRecordInfoFromTypeInfo(unknown_t *pTypeInfo, unknown_t **ppRecInfo);
HRESULT VarUI8FromI8(LONG64 ui64In, ULONG64 *pi64Out);
void objc_release(void *instance);
long SetPrinterDataA(HPRINTER hPrinter, LPSTR pValueName, unknown_t Type, LPBYTE pData, int cbData);
DWORD GetVersion();
BOOL SetProcessMitigationPolicy(PROCESS_MITIGATION_POLICY MitigationPolicy, PVOID lpBuffer, SIZE_T dwLength);
HRESULT VarUI8FromI2(SHORT sIn, ULONG64 *pi64Out);
HRESULT DeleteAppContainerProfile(PCWSTR pszAppContainerName);
HRESULT VarUI8FromI1(CHAR cIn, ULONG64 *pi64Out);
LSTATUS RegDeleteTreeA(HKEY hKey, LPCSTR lpSubKey);
int isatty(int fd);
HANDLE FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData);
HRESULT VarUI8FromI4(LONG lIn, ULONG64 *pi64Out);
BOOL SubtractRect(LPRECT lprcDst, RECT *lprcSrc1, RECT *lprcSrc2);
BOOL RefreshPolicy(BOOL bMachine);
BOOL CreateTimerQueueTimer(PHANDLE phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags);
long DocumentPropertiesA(HWND hWnd, HPRINTER hPrinter, LPSTR pDeviceName, unknown_t pDevModeOutput, unknown_t pDevModeInput, unknown_t fMode);
BOOL FindNextVolumeMountPointA(HANDLE hFindVolumeMountPoint, LPSTR lpszVolumeMountPoint, DWORD cchBufferLength);
BOOL CertSerializeCRLStoreElement(PCCRL_CONTEXT pCrlContext, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement);
LSTATUS RegDeleteTreeW(HKEY hKey, LPCWSTR lpSubKey);
int SelectClipRgn(HDC hdc, HRGN HRGN);
int GetArcDirection(HDC hdc);
void WSASetLastError(int iError);
bool isgreaterequal(double x, double y);
BOOL UnlockServiceDatabase(SC_LOCK ScLock);
BOOL GetNamedPipeHandleStateA(HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPSTR lpUserName, DWORD nMaxUserNameSize);
BOOL FindNextVolumeMountPointW(HANDLE hFindVolumeMountPoint, LPWSTR lpszVolumeMountPoint, DWORD cchBufferLength);
HPRINTER AddPrinterA(LPSTR pName, int Level, LPBYTE pPrinter);
LSTATUS RegRenameKey(HKEY hKey, LPCWSTR lpSubKeyName, LPCWSTR lpNewKeyName);
long double floorl(long double x);
BOOL CertAddCRLContextToStore(HCERTSTORE hCertStore, PCCRL_CONTEXT pCrlContext, DWORD dwAddDisposition, PCCRL_CONTEXT *ppStoreContext);
CONFIGRET CM_Get_Res_Des_Data_Ex(RES_DES rdResDes, PVOID Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine);
intmax_t imaxabs(intmax_t j);
long DocumentPropertiesW(HWND hWnd, HPRINTER hPrinter, LPWSTR pDeviceName, unknown_t pDevModeOutput, unknown_t pDevModeInput, unknown_t fMode);
BOOL ScheduleJob(HPRINTER hPrinter, DWORD dwJobID);
DWORD WinHttpGetProxyResult(HINTERNET hResolver, unknown_t *pProxyResult);
ATOM FindAtomW(LPCWSTR lpString);
BOOL EnumerateLoadedModulesExW(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, PVOID UserContext);
BOOL UnhookWinEvent(HWINEVENTHOOK hWinEventHook);
float floorf(float x);
HRESULT GetHGlobalFromStream(LPSTREAM pstm, HGLOBAL *phglobal);
BOOL SymSrvGetFileIndexesW(PCWSTR File, GUID *Id, PDWORD Val1, PDWORD Val2, DWORD Flags);
SECURITY_STATUS NCryptSignHash(NCRYPT_KEY_HANDLE hKey, VOID *pPaddingInfo, PBYTE pbHashValue, DWORD cbHashValue, PBYTE pbSignature, DWORD cbSignature, DWORD *pcbResult, DWORD dwFlags);
PWSTR StrCpyNW(PWSTR pszDst, PCWSTR pszSrc, int cchMax);
PCCTL_CONTEXT CertFindCTLInStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType, DWORD dwFindFlags, DWORD dwFindType, const void *pvFindPara, PCCTL_CONTEXT pPrevCtlContext);
DWORD CheckMenuItem(HMENU hMenu, UINT uIDCheckItem, UINT uCheck);
DWORD StrCatChainW(PWSTR pszDst, DWORD cchDst, DWORD ichAt, PCWSTR pszSrc);
HPRINTER AddPrinterW(LPWSTR pName, int Level, LPBYTE pPrinter);
BOOL GetNamedPipeHandleStateW(HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPWSTR lpUserName, DWORD nMaxUserNameSize);
BOOL ContinueDebugEvent(DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus);
int GetSystemDefaultLocaleName(LPWSTR lpLocaleName, int cchLocaleName);
COLORREF GetDCPenColor();
BOOL SetStdHandleEx(DWORD nStdHandle, HANDLE hHandle, PHANDLE phPrevValue);
DWORD GetFirmwareEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpGuid, PVOID pBuffer, DWORD nSize);
BOOL GetDiskFreeSpaceW(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters);
BOOL EnumPrinterDriversW(LPWSTR pName, LPWSTR pEnvironment, int Level, LPBYTE pDriverInfo, int cbBuf, int *pcbNeeded, int *pcReturned);
UINT GetSystemWow64Directory2A(LPSTR lpBuffer, UINT uSize, WORD ImageFileMachineType);
HRESULT SHGetViewStatePropertyBag(unknown_t pidl, PCWSTR pszBagName, DWORD dwFlags, REFIID riid, void **ppv);
ATOM FindAtomA(LPCSTR lpString);
PVOID ImageDirectoryEntryToData(PVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size);
HANDLE CreateTimerQueue();
HANDLE FindFirstStreamW(LPCWSTR lpFileName, STREAM_INFO_LEVELS InfoLevel, LPVOID lpFindStreamData, DWORD dwFlags);
DWORD GetFirmwareEnvironmentVariableA(LPCSTR lpName, LPCSTR lpGuid, PVOID pBuffer, DWORD nSize);
BOOL AllocConsole();
BOOL EqualRgn(HRGN hSrcRgn1, HRGN hSrcRgn2);
BOOL DrawMenuBar(HWND hWnd);
BOOL SymGetLineFromInlineContextW(HANDLE hProcess, DWORD64 dwAddr, ULONG InlineContext, DWORD64 qwModuleBaseAddress, PDWORD pdwDisplacement, PIMAGEHLP_LINEW64 Line);
ULONG ldap_compare(LDAP *ld, const PSTR dn, const PSTR attr, PSTR value);
BOOL EnumPrinterDriversA(LPSTR pName, LPSTR pEnvironment, int Level, LPBYTE pDriverInfo, int cbBuf, int *pcbNeeded, int *pcReturned);
VOID InitializeSRWLock(PSRWLOCK SRWLock);
int GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData);
BOOL GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters);
UINT GetSystemWow64Directory2W(LPWSTR lpBuffer, UINT uSize, WORD ImageFileMachineType);
HANDLE WSAAsyncGetHostByName(HWND hWnd, u_int wMsg, const char *name, char *buf, int buflen);
BOOL CheckNameLegalDOS8Dot3A(LPCSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces, PBOOL pbNameLegal);
SIZE_T VirtualQueryEx(HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength);
HRESULT CreateErrorInfo(unknown_t **pperrinfo);
BOOL CertGetCertificateChain(HCERTCHAINENGINE hChainEngine, PCCERT_CONTEXT pCertContext, LPFILETIME pTime, HCERTSTORE hAdditionalStore, PCERT_CHAIN_PARA pChainPara, DWORD dwFlags, LPVOID pvReserved, PCCERT_CHAIN_CONTEXT *ppChainContext);
BOOL CertAddStoreToCollection(HCERTSTORE hCollectionStore, HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority);
BOOL CertAddEncodedCRLToStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, BYTE *pbCrlEncoded, DWORD cbCrlEncoded, DWORD dwAddDisposition, PCCRL_CONTEXT *ppCrlContext);
BOOL ImageList_Remove(HIMAGELIST himl, int i);
int GetLocaleInfoA(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchData);
char * strncpy(char *dest, const char *src, size_t  n);
INT WSALookupServiceNextW(HANDLE hLookup, DWORD dwControlFlags, LPDWORD lpdwBufferLength, LPWSAQUERYSETW lpqsResults);
HRESULT LoadIconWithScaleDown(HINSTANCE hinst, PCWSTR pszName, int cx, int cy, HICON *phico);
BOOL InitializeAcl(PACL pAcl, DWORD nAclLength, DWORD dwAclRevision);
ULONG ldap_search_st(LDAP *ld, PSTR base, ULONG scope, PSTR filter, PZPSTR attrs, ULONG attrsonly, struct l_timeval *timeout, PLDAPMessage *res);
BOOL CheckNameLegalDOS8Dot3W(LPCWSTR lpName, LPSTR lpOemName, DWORD OemNameSize, PBOOL pbNameContainsSpaces, PBOOL pbNameLegal);
BOOL Pie(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect, int nXRadial1, int nYRadial1, int nXRadial2, int nYRadial2);
BOOL CredIsMarshaledCredentialA(LPCSTR MarshaledCredential);
BOOL SetProcessDPIAware();
BOOL AccessCheckByTypeResultListAndAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccessList, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose);
HANDLE PowerCreateRequest(PREASON_CONTEXT Context);
INT WSALookupServiceNextA(HANDLE hLookup, DWORD dwControlFlags, LPDWORD lpdwBufferLength, LPWSAQUERYSETA lpqsResults);
BOOL CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
VOID AcquireSRWLockExclusive(PSRWLOCK SRWLock);
ULONG ldap_search_sA(LDAP *ld, const PSTR base, ULONG scope, const PSTR filter, PZPSTR attrs, ULONG attrsonly, LDAPMessage **res);
CONFIGRET CM_Set_DevNode_Property_ExW(DEVINST dnDevInst, unknown_t *PropertyKey, unknown_t PropertyType, PBYTE PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine);
float log2f(float x);
HRESULT VarUI2FromI1(CHAR cIn, USHORT *puiOut);
DWORD64 SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR ImageName, PCWSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, PMODLOAD_DATA Data, DWORD Flags);
BOOL Wow64GetThreadSelectorEntry(HANDLE hThread, DWORD dwSelector, PWOW64_LDT_ENTRY lpSelectorEntry);
NTSTATUS BCryptImportKeyPair(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_KEY_HANDLE hImportKey, LPCWSTR pszBlobType, BCRYPT_KEY_HANDLE *phKey, PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
ULONG ldap_parse_page_controlA(PLDAP ExternalHandle, PLDAPControlA *ServerControls, ULONG *TotalCount, struct berval **Cookie);
BOOL CredIsMarshaledCredentialW(LPCWSTR MarshaledCredential);
ULONG ldap_create_sort_controlW(PLDAP ExternalHandle, PLDAPSortKeyW *SortKeys, UCHAR IsCritical, PLDAPControlW *Control);
HRESULT VarUI2FromI2(SHORT uiIn, USHORT *puiOut);
BOOL SetHandleInformation(HANDLE hObject, DWORD dwMask, DWORD dwFlags);
BOOL AddPrintProvidorW(LPWSTR pName, int level, LPBYTE pProvidorInfo);
HRESULT VarUI2FromI4(LONG lIn, USHORT *puiOut);
BOOL AccessCheckByTypeResultListAndAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose);
long double asinhl(long double x);
HRESULT VarUI2FromI8(LONG64 i64In, USHORT *puiOut);
long double log2l(long double x);
BOOL AlphaBlend(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, unknown_t blendFunction);
HCRYPTMSG CryptMsgOpenToEncode(DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo);
void IUnknown_Set(IUnknown **ppunk, IUnknown *punk);
HRESULT CoGetCallerTID(LPDWORD lpdwTID);
ULONG ldap_create_sort_controlA(PLDAP ExternalHandle, PLDAPSortKeyA *SortKeys, UCHAR IsCritical, PLDAPControlA *Control);
BOOL GetBitmapDimensionEx(HBITMAP hBitmap, LPSIZE lpDimension);
float asinhf(float x);
ULONG ldap_search_sW(LDAP *ld, PWSTR base, ULONG scope, PWSTR filter, PZPWSTR attrs, ULONG attrsonly, LDAPMessage **res);
ULONG ldap_parse_page_controlW(PLDAP ExternalHandle, PLDAPControlW *ServerControls, ULONG *TotalCount, struct berval **Cookie);
int GetCalendarInfoA(LCID Locale, CALID Calendar, CALTYPE CalType, LPSTR lpCalData, int cchData, LPDWORD lpValue);
HANDLE CreateFileMappingNumaW(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName, DWORD nndPreferred);
BOOL AddPrintProvidorA(LPSTR pName, int level, LPBYTE pProvidorInfo);
long _hread(HFILE hFile, LPVOID lpBuffer, long lBytes);
int GetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue);
HANDLE CreateFileMappingNumaA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName, DWORD nndPreferred);
BOOL SetRectRgn(HRGN HRGN, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
UINT SafeArrayGetDim(unknown_t *psa);
NTSTATUS NtQuerySystemTime(PLARGE_INTEGER SystemTime);
BOOL GetPrintProcessorDirectoryW(LPWSTR pName, LPWSTR pEnvironment, int Level, LPBYTE pPrintProcessorInfo, int cbBuf, LPDWORD pcbNeeded);
int ImageList_AddMasked(HIMAGELIST himl, HBITMAP hbmImage, COLORREF crMask);
HRESULT SetErrorInfo(ULONG dwReserved, unknown_t *perrinfo);
int StrToIntW(PCWSTR pszSrc);
BOOL SymGetExtendedOption(IMAGEHLP_EXTENDED_OPTIONS option);
BOOL SetWindowExtEx(HDC hdc, int nXExtent, int nYExtent, LPSIZE lpSize);
BOOL AddPrinterDriverW(LPWSTR pName, int Level, LPBYTE pDriverInfo);
HRESULT VarCyFix(unknown_t cyIn, unknown_t pcyResult);
HRESULT Freeze(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze);
BOOL SymGetSourceFileToken(HANDLE hProcess, ULONG64 Base, PCSTR FileSpec, PVOID *Token, DWORD *Size);
int fesetexceptflag(fexcept_t *arg, int excepts);
HRESULT UnregisterApplicationRestart();
BOOL ValidateRect(HWND hWnd, RECT *lpRect);
BOOL GetCharWidthI(HDC hdc, UINT giFirst, UINT cgi, LPWORD pgi, LPINT lpBuffer);
PCTL_ENTRY CertFindSubjectInCTL(DWORD dwEncodingType, DWORD dwSubjectType, void *pvSubject, PCCTL_CONTEXT pCtlContext, DWORD dwFlags);
HANDLE CreateEventExW(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
int StrToIntA(PCSTR pszSrc);
BOOL IsCharAlphaNumericW(WCHAR ch);
BOOL GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode);
BOOL GetNamedPipeClientProcessId(HANDLE Pipe, PULONG ClientProcessId);
VOID WaitForThreadpoolIoCallbacks(PTP_IO pio, BOOL fCancelPendingCallbacks);
BOOL GetCharWidthA(HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer);
BOOL GetPrintProcessorDirectoryA(LPSTR pName, LPSTR pEnvironment, int Level, LPBYTE pPrintProcessorInfo, int cbBuf, LPDWORD pcbNeeded);
VOID CertFreeCertificateChainEngine(HCERTCHAINENGINE hChainEngine);
BOOL CertAddCRLLinkToStore(HCERTSTORE hCertStore, PCCRL_CONTEXT pCrlContext, DWORD dwAddDisposition, PCCRL_CONTEXT *ppStoreContext);
BOOL DecryptFileA(LPCSTR lpFileName, DWORD dwReserved);
HANDLE CreateEventExA(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
BOOL AddPrinterDriverA(LPSTR pName, int Level, LPBYTE pDriverInfo);
BOOL IsCharAlphaNumericA(CHAR ch);
BOOL SwitchToThread();
HRESULT PathAllocCanonicalize(PCWSTR pszPathIn, ULONG dwFlags, PWSTR *ppszPathOut);
HENHMETAFILE SetEnhMetaFileBits(UINT cbBuffer, BYTE *lpData);
BOOL CryptSetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD dwFlags);
BOOL QueryServiceStatusEx(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded);
BOOL SetPrinterA(HPRINTER hPrinter, int Level, LPBYTE pPrinter, unknown_t Command);
BOOL DecryptFileW(LPCWSTR lpFileName, DWORD dwReserved);
HRESULT VarCmp(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid, ULONG dwFlags);
size_t mbrlen(const char *s, size_t n, mbstate_t *ps);
BOOL GetCharWidthW(HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer);
BOOL FillConsoleOutputCharacterW(HANDLE hConsoleOutput, WCHAR cCharacter, DWORD nLength, COORD dwWriteCoord, LPDWORD lpNumberOfCharsWritten);
LCID ConvertDefaultLocale(LCID Locale);
BOOL SymSrvGetFileIndexInfo(PCSTR File, PSYMSRV_INDEX_INFO Info, DWORD Flags);
int FlatSB_SetScrollRange(HWND ARG_0, int code, int min, int max, BOOL fRedraw);
DWORD WinHttpReadProxySettings(HINTERNET hSession, PCWSTR pcwszConnectionName, BOOL fFallBackToDefaultSettings, BOOL fSetAutoDiscoverForDefaultSettings, DWORD *pdwSettingsVersion, BOOL *pfDefaultSettingsAreReturned, unknown_t *pWinHttpProxySettings);
BOOL SetThreadPriorityBoost(HANDLE hThread, BOOL bDisablePriorityBoost);
int WSCGetApplicationCategory(LPCWSTR Path, DWORD PathLength, LPCWSTR Extra, DWORD ExtraLength, DWORD *pPermittedLspCategories, LPINT lpErrno);
HANDLE SetTimerQueueTimer(HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, BOOL PreferIo);
BOOL CertGetIntendedKeyUsage(DWORD dwCertEncodingType, PCERT_INFO pCertInfo, BYTE *pbKeyUsage, DWORD cbKeyUsage);
HRESULT CoGetMalloc(DWORD dwMemContext, LPMALLOC *ppMalloc);
BOOL FillConsoleOutputCharacterA(HANDLE hConsoleOutput, CHAR cCharacter, DWORD nLength, COORD dwWriteCoord, LPDWORD lpNumberOfCharsWritten);
LPSTR CharPrevA(LPCSTR lpszStart, LPCSTR lpszCurrent);
int WSCGetProviderInfo32(LPGUID lpProviderId, WSC_PROVIDER_INFO_TYPE InfoType, PBYTE Info, size_t *InfoSize, DWORD Flags, LPINT lpErrno);
CONFIGRET CM_Query_Arbitrator_Free_Size(PULONG pulSize, DEVINST dnDevInst, RESOURCEID ResourceID, ULONG ulFlags);
int wcscoll(wchar_t *s1, wchar_t *s2);
BOOLEAN TryAcquireSRWLockExclusive(PSRWLOCK SRWLock);
BOOL SetPrinterW(HPRINTER hPrinter, int Level, LPBYTE pPrinter, unknown_t Command);
BOOL GetNumaNodeProcessorMaskEx(USHORT Node, unknown_t ProcessorMask);
HRESULT CoSuspendClassObjects();
HRESULT VarBstrCat(BSTR bstrLeft, BSTR bstrRight, LPBSTR pbstrResult);
BOOL WritePrivateProfileSectionW(LPCWSTR lpAppName, LPCWSTR lpString, LPCWSTR lpFileName);
LPWSTR CharPrevW(LPCWSTR lpszStart, LPCWSTR lpszCurrent);
BOOL CreateWellKnownSid(WELL_KNOWN_SID_TYPE WellKnownSidType, PSID DomainSid, PSID pSid, DWORD *cbSid);
BOOL DequeueUmsCompletionListItems(PUMS_COMPLETION_LIST UmsCompletionList, DWORD WaitTimeOut, PUMS_CONTEXT *UmsThreadList);
BOOL AnimatePalette(HPALETTE hpal, UINT iStartIndex, UINT cEntries, unknown_t *ppe);
LSTATUS RegOpenKeyTransactedW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult, HANDLE hTransaction, PVOID pExtendedParemeter);
long double fmal(long double x, long double y, long double z);
int fegetexceptflag(fexcept_t *flagp, int excepts);
BOOL LookupPrivilegeNameW(LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName, LPDWORD cchName);
const void * CertCreateContext(DWORD dwContextType, DWORD dwEncodingType, BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCERT_CREATE_CONTEXT_PARA pCreatePara);
HRESULT AssocGetPerceivedType(PCWSTR pszExt, unknown_t *ptype, unknown_t *pflag, PWSTR *ppszType);
CONFIGRET CM_Get_Class_NameA(LPGUID ClassGuid, PSTR Buffer, PULONG pulLength, ULONG ulFlags);
DWORD GetMessagePos();
float fmaf(float x, float y, float z);
long SetDIBits(HDC hdc, HBITMAP hbmp, UINT uStartScan, UINT cScanLines, VOID *lpvBits, BITMAPINFO *lpbmi, unknown_t fuColorUse);
LPSTR CharNextExA(WORD CodePage, LPCSTR lpCurrentChar, DWORD dwFlags);
int GetNumberFormatEx(LPCWSTR lpLocaleName, DWORD dwFlags, LPCWSTR lpValue, unknown_t *lpFormat, LPWSTR lpNumberStr, int cchNumber);
BOOL SetMenuContextHelpId(HMENU ARG_0, DWORD ARG_1);
int strncmp(const char *s1, const char *s2, size_t n);
LSTATUS RegOpenKeyTransactedA(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult, HANDLE hTransaction, PVOID pExtendedParemeter);
ULONG ldap_delete_ext(LDAP *ld, const PSTR dn, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, ULONG *MessageNumber);
HRESULT SafeArrayGetRecordInfo(unknown_t *psa, unknown_t **prinfo);
float erfcf(float x);
BOOL WritePrivateProfileSectionA(LPCSTR lpAppName, LPCSTR lpString, LPCSTR lpFileName);
HICON CreateIcon(HINSTANCE hInstance, int nWidth, int nHeight, BYTE cPlanes, BYTE cBitsPixel, BYTE *lpbANDbits, BYTE *lpbXORbits);
HRESULT DispCallFunc(void *pvInstance, ULONG_PTR oVft, unknown_t cc, VARTYPE vtReturn, UINT cActuals, VARTYPE *prgvt, unknown_t **prgpvarg, VARIANT *pvargResult);
int SetAbortProc(HDC hdc, unknown_t pfnAbort);
BOOL GetPointerFrameInfo(UINT32 pointerId, UINT32 *pointerCount, unknown_t *pointerInfo);
DWORD GetSysColor(int nIndex);
BOOL GetFileMUIInfo(DWORD dwFlags, PCWSTR pcwszFilePath, PFILEMUIINFO pFileMUIInfo, DWORD *pcbFileMUIInfo);
BOOL IsEnclaveTypeSupported(DWORD flEnclaveType);
double fmax(double x, double y);
CONFIGRET CM_Get_Class_NameW(LPGUID ClassGuid, PWSTR Buffer, PULONG pulLength, ULONG ulFlags);
HRESULT LockServer();
int vfscanf(FILE *stream, const char *format, va_list ap);
BOOL EnumPrintersA(unknown_t Flags, LPSTR Name, int Level, LPBYTE pPrinterEnum, int cbBuf, unknown_t *pcbNeeded, int *pcReturned);
BOOL VirtualLock(LPVOID lpAddress, SIZE_T dwSize);
HRESULT VarI4FromI2(SHORT sIn, LONG *plOut);
long double erfcl(long double x);
VOID CertAddRefServerOcspResponse(HCERT_SERVER_OCSP_RESPONSE hServerOcspResponse);
BOOL LookupPrivilegeNameA(LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName, LPDWORD cchName);
HANDLE HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize);
CONFIGRET CM_Get_Sibling(unknown_t pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
HWND SetCapture(HWND hWnd);
HRESULT RsopFileAccessCheck(LPWSTR pszFileName, unknown_t pRsopToken, DWORD dwDesiredAccessMask, LPDWORD pdwGrantedAccessMask, LPBOOL pbAccessStatus);
HRESULT VarI4FromI1(CHAR cIn, LONG *plOut);
BOOL WinHttpReadData(HINTERNET hRequest, LPVOID lpBuffer, DWORD dwNumberOfBytesToRead, LPDWORD lpdwNumberOfBytesRead);
CONFIGRET CM_Free_Res_Des_Ex(PRES_DES prdResDes, RES_DES rdResDes, ULONG ulFlags, HMACHINE hMachine);
BOOL CloseEventLog(HANDLE hEventLog);
BOOL GetKeyboardState(PBYTE lpKeyState);
ssize_t read(int fildes, void *buf, size_t nbyte);
HRESULT VarI4FromI8(LONG64 i64In, LONG *plOut);
NTSTATUS BCryptProcessMultiOperations(BCRYPT_HANDLE hObject, unknown_t operationType, PVOID pOperations, ULONG cbOperations, ULONG dwFlags);
int WSCSetProviderInfo(LPGUID lpProviderId, WSC_PROVIDER_INFO_TYPE InfoType, PBYTE Info, size_t InfoSize, DWORD Flags, LPINT lpErrno);
BOOL SymEnumTypesW(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, PVOID UserContext);
BOOL EnumPrintersW(unknown_t Flags, LPWSTR Name, int Level, LPBYTE pPrinterEnum, int cbBuf, unknown_t *pcbNeeded, int *pcReturned);
int EnumPropsExA(HWND hWnd, PROPENUMPROCEXA lpEnumFunc, LPARAM lParam);
ULONG ldap_extended_operation_sA(LDAP *ExternalHandle, PSTR Oid, struct berval *Data, PLDAPControlA *ServerControls, PLDAPControlA *ClientControls, PCHAR *ReturnedOid, struct berval **ReturnedData);
BOOL EnterUmsSchedulingMode(PUMS_SCHEDULER_STARTUP_INFO SchedulerStartupInfo);
HWND GetWindow(HWND hWnd, UINT uCmd);
HRESULT UninitializeFlatSB(HWND ARG_0);
BOOL FindNextPrinterChangeNotification(HPRINTER hChange, PDWORD pdwChange, LPVOID pPrinterNotifyOptions, LPVOID *ppPrinterNotifyInfo);
NTSTATUS BCryptDeriveKeyPBKDF2(BCRYPT_ALG_HANDLE hPrf, PUCHAR pbPassword, ULONG cbPassword, PUCHAR pbSalt, ULONG cbSalt, ULONGLONG cIterations, PUCHAR pbDerivedKey, ULONG cbDerivedKey, ULONG dwFlags);
double copysign(double x, double y);
HMENU GetSubMenu(HMENU hMenu, int nPos);
DWORD IsValidNLSVersion(NLS_FUNCTION function, LPCWSTR lpLocaleName, LPNLSVERSIONINFOEX lpVersionInformation);
int EnumPropsExW(HWND hWnd, unknown_t lpEnumFunc, LPARAM lParam);
BOOL GetNamedPipeServerProcessId(HANDLE Pipe, PULONG ServerProcessId);
ULONG ldap_extended_operation_sW(LDAP *ExternalHandle, PWSTR Oid, struct berval *Data, PLDAPControlW *ServerControls, PLDAPControlW *ClientControls, PWCHAR *ReturnedOid, struct berval **ReturnedData);
BOOL GetSystemTimes(PFILETIME lpIdleTime, PFILETIME lpKernelTime, PFILETIME lpUserTime);
UCHAR GetTraceEnableLevel(TRACEHANDLE TraceHandle);
LONG GetMessageTime();
int GetClassNameW(HWND hWnd, LPWSTR lpClassName, int nMaxCount);
u_short ntohs(u_short netshort);
int WPUQueryBlockingCallback(DWORD dwCatalogEntryId, LPBLOCKINGCALLBACK *lplpfnCallback, PDWORD_PTR lpdwContext, LPINT lpErrno);
long ChoosePixelFormat(HDC hdc, unknown_t *ppfd);
INT ShellAboutW(HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff, HICON hIcon);
HRESULT CoRegisterActivationFilter(unknown_t *pActivationFilter);
BOOL IsTextUnicode(VOID *lpv, int iSize, LPINT lpiResult);
HRESULT RsopSetPolicySettingStatus(DWORD dwFlags, unknown_t *pServices, unknown_t *pSettingInstance, DWORD nInfo, unknown_t *pStatus);
u_long ntohl(u_long netlong);
BOOL QueryVirtualMemoryInformation(HANDLE Process, VOID *VirtualAddress, WIN32_MEMORY_INFORMATION_CLASS MemoryInformationClass, PVOID MemoryInformation, SIZE_T MemoryInformationSize, PSIZE_T ReturnSize);
VOID AddRefActCtx(HANDLE hActCtx);
BOOL NotifyUILanguageChange(DWORD dwFlags, PCWSTR pcwstrNewLanguage, PCWSTR pcwstrPreviousLanguage, DWORD dwReserved, PDWORD pdwStatusRtrn);
int recv(SOCKET s, char *buf, int len, int flags);
int GetClassNameA(HWND hWnd, LPSTR lpClassName, int nMaxCount);
BOOL SetProcessValidCallTargets(HANDLE hProcess, PVOID VirtualAddress, SIZE_T RegionSize, ULONG NumberOfOffsets, PCFG_CALL_TARGET_INFO OffsetInformation);
HRESULT VarAbs(LPVARIANT pvarIn, LPVARIANT pvarResult);
HRESULT CoCreateGuid(GUID *pguid);
int snprintf(char *s, size_t size, const char *format, va_list args);
double ntohd(__uint64 Value);
BOOL SetWindowDisplayAffinity(HWND hWnd, DWORD dwAffinity);
DWORD GetCurrentProcessorNumber();
float ntohf(__uint32 Value);
BOOL CancelTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer);
BOOL IsMenu(HMENU hMenu);
DWORD GetEnhMetaFilePaletteEntries(HENHMETAFILE hemf, UINT cEntries, unknown_t lppe);
EOF
RUN

NAME=tn test
FILE=--
CMDS=<<EOF
tn fun1
tn fun2
tn
tnj
EOF
EXPECT=<<EOF
fun1
fun2
["fun1","fun2"]
EOF
RUN

NAME=no ESIL memory in aaft
FILE=bins/elf/back1
CMDS=<<EOF
aa
s main
oml
aaft
oml
EOF
EXPECT=<<EOF
 1 fd: 4 +0x00000000 0x00201020 - 0x00201087 r-- vmap.reloc-targets
 2 fd: 3 +0x00000000 0x00000000 * 0x000009af r-x fmap.LOAD0
 3 fd: 5 +0x00000000 0x00201010 - 0x00201017 rw- mmap.LOAD1
 4 fd: 6 +0x00000d98 0x00200d98 - 0x0020100f r-- vmap.LOAD1
 1 fd: 4 +0x00000000 0x00201020 - 0x00201087 r-- vmap.reloc-targets
 2 fd: 3 +0x00000000 0x00000000 * 0x000009af r-x fmap.LOAD0
 3 fd: 5 +0x00000000 0x00201010 - 0x00201017 rw- mmap.LOAD1
 4 fd: 6 +0x00000d98 0x00200d98 - 0x0020100f r-- vmap.LOAD1
EOF
RUN
