; Listing generated by Microsoft (R) Optimizing Compiler Version 19.36.32537.0 

include listing.inc

INCLUDELIB OLDNAMES

PUBLIC	??_C@_05JMLLFKBP@?$CFllu?6@			; `string'
EXTRN	__imp___stdio_common_vfprintf:PROC
EXTRN	__imp___acrt_iob_func:PROC
;	COMDAT ??_C@_05JMLLFKBP@?$CFllu?6@
CONST	SEGMENT
??_C@_05JMLLFKBP@?$CFllu?6@ DB '%llu', 0aH, 00H		; `string'
PUBLIC	deinit_matmap_sse
PUBLIC	deinitM128
PUBLIC	transpose_ssemat_2
PUBLIC	set_m128ptr_default
PUBLIC	tranpose_4x4matmap
PUBLIC	load_matmap
PUBLIC	sqrtss_const
PUBLIC	divps
PUBLIC	divps_const
PUBLIC	mulps_sum
PUBLIC	mulps
PUBLIC	mulps_const
PUBLIC	subps
PUBLIC	addps
PUBLIC	load_cpy
PUBLIC	load
PUBLIC	printf
PUBLIC	_vfprintf_l
PUBLIC	__local_stdio_printf_options
;	COMDAT pdata
pdata	SEGMENT
$pdata$transpose_ssemat_2 DD imagerel $LN11
	DD	imagerel $LN11+162
	DD	imagerel $unwind$transpose_ssemat_2
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$tranpose_4x4matmap DD imagerel $LN6
	DD	imagerel $LN6+249
	DD	imagerel $unwind$tranpose_4x4matmap
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$load_matmap DD imagerel $LN7
	DD	imagerel $LN7+134
	DD	imagerel $unwind$load_matmap
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$divps DD	imagerel $LN7
	DD	imagerel $LN7+72
	DD	imagerel $unwind$divps
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$divps_const DD imagerel $LN7
	DD	imagerel $LN7+68
	DD	imagerel $unwind$divps_const
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$mulps DD	imagerel $LN7
	DD	imagerel $LN7+72
	DD	imagerel $unwind$mulps
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$mulps_const DD imagerel $LN7
	DD	imagerel $LN7+65
	DD	imagerel $unwind$mulps_const
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$subps DD	imagerel $LN7
	DD	imagerel $LN7+73
	DD	imagerel $unwind$subps
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$addps DD	imagerel $LN7
	DD	imagerel $LN7+73
	DD	imagerel $unwind$addps
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$load_cpy DD imagerel $LN7
	DD	imagerel $LN7+40
	DD	imagerel $unwind$load_cpy
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$load DD	imagerel $LN6
	DD	imagerel $LN6+71
	DD	imagerel $unwind$load
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$printf DD imagerel $LN6
	DD	imagerel $LN6+85
	DD	imagerel $unwind$printf
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$_vfprintf_l DD imagerel $LN4
	DD	imagerel $LN4+68
	DD	imagerel $unwind$_vfprintf_l
;	COMDAT xdata
xdata	SEGMENT
$unwind$_vfprintf_l DD 060f01H
	DD	09640fH
	DD	08340fH
	DD	0700b520fH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$printf DD 041b01H
	DD	07017521bH
	DD	030156016H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$load DD	010401H
	DD	06204H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$load_cpy DD 020601H
	DD	030023206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$addps DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$subps DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$mulps_const DD 020901H
	DD	030055209H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$mulps DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$divps_const DD 020901H
	DD	030055209H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$divps DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$load_matmap DD 082419H
	DD	0e7415H
	DD	0d6415H
	DD	0c3415H
	DD	0e0119215H
	DD	imagerel __GSHandlerCheck
	DD	040H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$tranpose_4x4matmap DD 0a1a01H
	DD	09e41aH
	DD	08741aH
	DD	07641aH
	DD	06341aH
	DD	0f016321aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$transpose_ssemat_2 DD 060f01H
	DD	07640fH
	DD	06340fH
	DD	0700b320fH
; Function compile flags: /Ogtpy
; File C:\Program Files (x86)\Windows Kits\10\Include\10.0.22000.0\ucrt\corecrt_stdio_config.h
;	COMDAT __local_stdio_printf_options
_TEXT	SEGMENT
__local_stdio_printf_options PROC			; COMDAT

; 91   :         static unsigned __int64 _OptionsStorage;
; 92   :         return &_OptionsStorage;

  00000	48 8d 05 00 00
	00 00		 lea	 rax, OFFSET FLAT:?_OptionsStorage@?1??__local_stdio_printf_options@@9@9 ; `__local_stdio_printf_options'::`2'::_OptionsStorage

; 93   :     }

  00007	c3		 ret	 0
__local_stdio_printf_options ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File C:\Program Files (x86)\Windows Kits\10\Include\10.0.22000.0\ucrt\stdio.h
;	COMDAT _vfprintf_l
_TEXT	SEGMENT
_Stream$ = 64
_Format$ = 72
_Locale$dead$ = 80
_ArgList$ = 88
_vfprintf_l PROC					; COMDAT

; 644  :     {

$LN4:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	57		 push	 rdi
  0000b	48 83 ec 30	 sub	 rsp, 48			; 00000030H
  0000f	49 8b d9	 mov	 rbx, r9
  00012	48 8b fa	 mov	 rdi, rdx
  00015	48 8b f1	 mov	 rsi, rcx

; 645  :         return __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, _Stream, _Format, _Locale, _ArgList);

  00018	e8 00 00 00 00	 call	 __local_stdio_printf_options
  0001d	45 33 c9	 xor	 r9d, r9d
  00020	48 89 5c 24 20	 mov	 QWORD PTR [rsp+32], rbx
  00025	4c 8b c7	 mov	 r8, rdi
  00028	48 8b d6	 mov	 rdx, rsi
  0002b	48 8b 08	 mov	 rcx, QWORD PTR [rax]
  0002e	ff 15 00 00 00
	00		 call	 QWORD PTR __imp___stdio_common_vfprintf

; 646  :     }

  00034	48 8b 5c 24 40	 mov	 rbx, QWORD PTR [rsp+64]
  00039	48 8b 74 24 48	 mov	 rsi, QWORD PTR [rsp+72]
  0003e	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00042	5f		 pop	 rdi
  00043	c3		 ret	 0
_vfprintf_l ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File C:\Program Files (x86)\Windows Kits\10\Include\10.0.22000.0\ucrt\stdio.h
;	COMDAT printf
_TEXT	SEGMENT
_Format$ = 80
printf	PROC						; COMDAT

; 956  :     {

$LN6:
  00000	48 89 4c 24 08	 mov	 QWORD PTR [rsp+8], rcx
  00005	48 89 54 24 10	 mov	 QWORD PTR [rsp+16], rdx
  0000a	4c 89 44 24 18	 mov	 QWORD PTR [rsp+24], r8
  0000f	4c 89 4c 24 20	 mov	 QWORD PTR [rsp+32], r9
  00014	53		 push	 rbx
  00015	56		 push	 rsi
  00016	57		 push	 rdi
  00017	48 83 ec 30	 sub	 rsp, 48			; 00000030H
  0001b	48 8b f9	 mov	 rdi, rcx

; 957  :         int _Result;
; 958  :         va_list _ArgList;
; 959  :         __crt_va_start(_ArgList, _Format);

  0001e	48 8d 74 24 58	 lea	 rsi, QWORD PTR _Format$[rsp+8]

; 960  :         _Result = _vfprintf_l(stdout, _Format, NULL, _ArgList);

  00023	b9 01 00 00 00	 mov	 ecx, 1
  00028	ff 15 00 00 00
	00		 call	 QWORD PTR __imp___acrt_iob_func
  0002e	48 8b d8	 mov	 rbx, rax

; 645  :         return __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, _Stream, _Format, _Locale, _ArgList);

  00031	e8 00 00 00 00	 call	 __local_stdio_printf_options
  00036	45 33 c9	 xor	 r9d, r9d
  00039	48 89 74 24 20	 mov	 QWORD PTR [rsp+32], rsi
  0003e	4c 8b c7	 mov	 r8, rdi
  00041	48 8b d3	 mov	 rdx, rbx
  00044	48 8b 08	 mov	 rcx, QWORD PTR [rax]
  00047	ff 15 00 00 00
	00		 call	 QWORD PTR __imp___stdio_common_vfprintf

; 961  :         __crt_va_end(_ArgList);
; 962  :         return _Result;
; 963  :     }

  0004d	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00051	5f		 pop	 rdi
  00052	5e		 pop	 rsi
  00053	5b		 pop	 rbx
  00054	c3		 ret	 0
printf	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT load
_TEXT	SEGMENT
array$ = 32
x$ = 64
y$ = 72
z$ = 80
w$ = 88
load	PROC						; COMDAT

; 20   : {

$LN6:
  00000	48 83 ec 38	 sub	 rsp, 56			; 00000038H

; 21   :     float array[4] = {x,y,z,w};
; 22   :     __m128* ptr = _aligned_malloc(sizeof(__m128),16);

  00004	ba 10 00 00 00	 mov	 edx, 16
  00009	f3 0f 11 44 24
	20		 movss	 DWORD PTR array$[rsp], xmm0
  0000f	8b ca		 mov	 ecx, edx
  00011	f3 0f 11 4c 24
	24		 movss	 DWORD PTR array$[rsp+4], xmm1
  00017	f3 0f 11 54 24
	28		 movss	 DWORD PTR array$[rsp+8], xmm2
  0001d	f3 0f 11 5c 24
	2c		 movss	 DWORD PTR array$[rsp+12], xmm3
  00023	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 23   : 
; 24   :     if (NULL != ptr)

  00029	48 85 c0	 test	 rax, rax
  0002c	74 0d		 je	 SHORT $LN2@load

; 25   :     {
; 26   :         *ptr = _mm_loadu_ps(&array);

  0002e	0f 10 44 24 20	 movups	 xmm0, XMMWORD PTR array$[rsp]
  00033	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 32   :     }
; 33   : }

  00036	48 83 c4 38	 add	 rsp, 56			; 00000038H
  0003a	c3		 ret	 0
$LN2@load:

; 27   :         return ptr;
; 28   :     }
; 29   :     else
; 30   :     {
; 31   :         return -1;

  0003b	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1

; 32   :     }
; 33   : }

  00042	48 83 c4 38	 add	 rsp, 56			; 00000038H
  00046	c3		 ret	 0
load	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT load_cpy
_TEXT	SEGMENT
ptr$ = 48
load_cpy PROC						; COMDAT

; 36   : {

$LN7:
  00000	40 53		 push	 rbx
  00002	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 37   :     __m128* ret = _aligned_malloc(sizeof(__m128*),16);

  00006	ba 10 00 00 00	 mov	 edx, 16
  0000b	48 8b d9	 mov	 rbx, rcx
  0000e	8d 4a f8	 lea	 ecx, QWORD PTR [rdx-8]
  00011	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 38   : 
; 39   :     if (NULL != ret)

  00017	48 85 c0	 test	 rax, rax
  0001a	74 06		 je	 SHORT $LN4@load_cpy

; 40   :     {
; 41   :         *ret = *ptr;

  0001c	0f 10 03	 movups	 xmm0, XMMWORD PTR [rbx]
  0001f	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0
$LN4@load_cpy:

; 42   :     }
; 43   : 
; 44   :     return ret;
; 45   : }

  00022	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00026	5b		 pop	 rbx
  00027	c3		 ret	 0
load_cpy ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT addps
_TEXT	SEGMENT
ptr1$ = 48
ptr2$ = 56
addps	PROC						; COMDAT

; 48   : {

$LN7:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000a	48 8b da	 mov	 rbx, rdx
  0000d	48 8b f9	 mov	 rdi, rcx

; 49   :     
; 50   :     __m128* ret = _aligned_malloc(sizeof(__m128*),16);

  00010	ba 10 00 00 00	 mov	 edx, 16
  00015	8d 4a f8	 lea	 ecx, QWORD PTR [rdx-8]
  00018	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 51   : 
; 52   :     if (NULL != ret)

  0001e	48 85 c0	 test	 rax, rax
  00021	74 14		 je	 SHORT $LN2@addps

; 53   :     {
; 54   :         *ret = _mm_add_ps(*ptr1, *ptr2);

  00023	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00026	0f 58 03	 addps	 xmm0, XMMWORD PTR [rbx]
  00029	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 55   :         return ret;
; 56   :     }
; 57   :     else
; 58   :     {
; 59   :         return -1;
; 60   :     }
; 61   : 
; 62   : }

  0002c	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00031	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00035	5f		 pop	 rdi
  00036	c3		 ret	 0
$LN2@addps:
  00037	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0003c	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  00043	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00047	5f		 pop	 rdi
  00048	c3		 ret	 0
addps	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT subps
_TEXT	SEGMENT
ptr1$ = 48
ptr2$ = 56
subps	PROC						; COMDAT

; 65   : {

$LN7:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000a	48 8b da	 mov	 rbx, rdx
  0000d	48 8b f9	 mov	 rdi, rcx

; 66   :     __m128* ret = _aligned_malloc(sizeof(__m128*), 16);

  00010	ba 10 00 00 00	 mov	 edx, 16
  00015	8d 4a f8	 lea	 ecx, QWORD PTR [rdx-8]
  00018	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 67   : 
; 68   :     if (NULL != ret)

  0001e	48 85 c0	 test	 rax, rax
  00021	74 14		 je	 SHORT $LN2@subps

; 69   :     {
; 70   :         *ret = _mm_sub_ps(*ptr1, *ptr2);

  00023	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00026	0f 5c 03	 subps	 xmm0, XMMWORD PTR [rbx]
  00029	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 71   :         return ret;
; 72   :     }
; 73   :     else
; 74   :     {
; 75   :         return -1;
; 76   :     }
; 77   : }

  0002c	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00031	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00035	5f		 pop	 rdi
  00036	c3		 ret	 0
$LN2@subps:
  00037	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0003c	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  00043	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00047	5f		 pop	 rdi
  00048	c3		 ret	 0
subps	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT mulps_const
_TEXT	SEGMENT
c$ = 32
ptr$ = 64
value$ = 72
mulps_const PROC					; COMDAT

; 80   : {

$LN7:
  00000	0f c6 c9 00	 shufps	 xmm1, xmm1, 0
  00004	53		 push	 rbx
  00005	48 83 ec 30	 sub	 rsp, 48			; 00000030H

; 81   :     float c[4] = { value, value, value, value };
; 82   :     __m128* ret = _aligned_malloc(sizeof(__m128),16);

  00009	ba 10 00 00 00	 mov	 edx, 16
  0000e	48 8b d9	 mov	 rbx, rcx
  00011	8b ca		 mov	 ecx, edx
  00013	0f 11 4c 24 20	 movups	 XMMWORD PTR c$[rsp], xmm1
  00018	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 83   : 
; 84   :     __m128 valueVec = _mm_loadu_ps(&c);
; 85   : 
; 86   :     if (NULL != ret)

  0001e	48 85 c0	 test	 rax, rax
  00021	74 11		 je	 SHORT $LN2@mulps_cons

; 87   :     {
; 88   :         *ret = _mm_mul_ps(*ptr,valueVec);

  00023	0f 10 44 24 20	 movups	 xmm0, XMMWORD PTR c$[rsp]
  00028	0f 59 03	 mulps	 xmm0, XMMWORD PTR [rbx]
  0002b	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 94   :     }
; 95   : }

  0002e	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00032	5b		 pop	 rbx
  00033	c3		 ret	 0
$LN2@mulps_cons:

; 89   :         return ret;
; 90   :     }
; 91   :     else
; 92   :     {
; 93   :         return -1;

  00034	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1

; 94   :     }
; 95   : }

  0003b	48 83 c4 30	 add	 rsp, 48			; 00000030H
  0003f	5b		 pop	 rbx
  00040	c3		 ret	 0
mulps_const ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT mulps
_TEXT	SEGMENT
ptr1$ = 48
ptr2$ = 56
mulps	PROC						; COMDAT

; 98   : {

$LN7:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000a	48 8b da	 mov	 rbx, rdx
  0000d	48 8b f9	 mov	 rdi, rcx

; 99   :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);

  00010	ba 10 00 00 00	 mov	 edx, 16
  00015	8b ca		 mov	 ecx, edx
  00017	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 100  : 
; 101  :     if (NULL != ret)

  0001d	48 85 c0	 test	 rax, rax
  00020	74 14		 je	 SHORT $LN2@mulps

; 102  :     {
; 103  :         *ret = _mm_mul_ps(*ptr1, *ptr2);

  00022	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00025	0f 59 03	 mulps	 xmm0, XMMWORD PTR [rbx]
  00028	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 104  :         return ret;
; 105  :     }
; 106  :     else
; 107  :     {
; 108  :         return -1;
; 109  :     }
; 110  : }

  0002b	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00030	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00034	5f		 pop	 rdi
  00035	c3		 ret	 0
$LN2@mulps:
  00036	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0003b	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  00042	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00046	5f		 pop	 rdi
  00047	c3		 ret	 0
mulps	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT mulps_sum
_TEXT	SEGMENT
ptr1$ = 8
ptr2$ = 16
mulps_sum PROC						; COMDAT

; 114  :     __m128 ret = _mm_mul_ps(*ptr1,*ptr2);

  00000	0f 10 01	 movups	 xmm0, XMMWORD PTR [rcx]
  00003	0f 59 02	 mulps	 xmm0, XMMWORD PTR [rdx]

; 115  :     ret = _mm_hadd_ps(ret,ret);

  00006	f2 0f 7c c0	 haddps	 xmm0, xmm0

; 116  :     ret = _mm_hadd_ps(ret,ret);

  0000a	f2 0f 7c c0	 haddps	 xmm0, xmm0

; 117  :     return *(float*)&ret;
; 118  : }

  0000e	c3		 ret	 0
mulps_sum ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT divps_const
_TEXT	SEGMENT
c$ = 32
ptr$ = 64
value$ = 72
divps_const PROC					; COMDAT

; 121  : {

$LN7:
  00000	0f c6 c9 00	 shufps	 xmm1, xmm1, 0
  00004	53		 push	 rbx
  00005	48 83 ec 30	 sub	 rsp, 48			; 00000030H

; 122  : 
; 123  :     float c[4] = { value, value, value, value };
; 124  :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);

  00009	ba 10 00 00 00	 mov	 edx, 16
  0000e	48 8b d9	 mov	 rbx, rcx
  00011	8b ca		 mov	 ecx, edx
  00013	0f 11 4c 24 20	 movups	 XMMWORD PTR c$[rsp], xmm1
  00018	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 125  : 
; 126  :     __m128 valueVec = _mm_loadu_ps(&c);
; 127  : 
; 128  :     if (NULL != ret)

  0001e	48 85 c0	 test	 rax, rax
  00021	74 14		 je	 SHORT $LN2@divps_cons

; 129  :     {
; 130  :         *ret = _mm_div_ps(*ptr, valueVec);

  00023	0f 10 0b	 movups	 xmm1, XMMWORD PTR [rbx]
  00026	0f 10 44 24 20	 movups	 xmm0, XMMWORD PTR c$[rsp]
  0002b	0f 5e c8	 divps	 xmm1, xmm0
  0002e	0f 11 08	 movups	 XMMWORD PTR [rax], xmm1

; 136  :     }
; 137  : }

  00031	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00035	5b		 pop	 rbx
  00036	c3		 ret	 0
$LN2@divps_cons:

; 131  :         return ret;
; 132  :     }
; 133  :     else
; 134  :     {
; 135  :         return -1;

  00037	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1

; 136  :     }
; 137  : }

  0003e	48 83 c4 30	 add	 rsp, 48			; 00000030H
  00042	5b		 pop	 rbx
  00043	c3		 ret	 0
divps_const ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT divps
_TEXT	SEGMENT
ptr1$ = 48
ptr2$ = 56
divps	PROC						; COMDAT

; 140  : {

$LN7:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	57		 push	 rdi
  00006	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  0000a	48 8b da	 mov	 rbx, rdx
  0000d	48 8b f9	 mov	 rdi, rcx

; 141  :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);

  00010	ba 10 00 00 00	 mov	 edx, 16
  00015	8b ca		 mov	 ecx, edx
  00017	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 142  : 
; 143  :     if (NULL != ret)

  0001d	48 85 c0	 test	 rax, rax
  00020	74 14		 je	 SHORT $LN2@divps

; 144  :     {
; 145  :         *ret = _mm_div_ps(*ptr1, *ptr2);

  00022	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00025	0f 5e 03	 divps	 xmm0, XMMWORD PTR [rbx]
  00028	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 146  :         return ret;
; 147  :     }
; 148  :     else
; 149  :     {
; 150  :         return -1;
; 151  :     }
; 152  : }

  0002b	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00030	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00034	5f		 pop	 rdi
  00035	c3		 ret	 0
$LN2@divps:
  00036	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0003b	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  00042	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00046	5f		 pop	 rdi
  00047	c3		 ret	 0
divps	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT sqrtss_const
_TEXT	SEGMENT
a$ = 8
sqrtss_const PROC					; COMDAT

; 156  :     __m128 ret = _mm_sqrt_ss(*(__m128*) & a);

  00000	0f 10 4c 24 08	 movups	 xmm1, XMMWORD PTR a$[rsp]
  00005	f3 0f 10 c8	 movss	 xmm1, xmm0
  00009	f3 0f 51 c9	 sqrtss	 xmm1, xmm1

; 157  : 
; 158  :     return ret.m128_f32[0];

  0000d	0f 28 c1	 movaps	 xmm0, xmm1

; 159  : 
; 160  :     
; 161  : 
; 162  : }

  00010	c3		 ret	 0
sqrtss_const ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT load_matmap
_TEXT	SEGMENT
ptr$ = 32
__$ArrayPad$ = 64
c0$ = 96
c1$ = 104
c2$ = 112
c3$ = 120
load_matmap PROC					; COMDAT

; 173  : {

$LN7:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	48 89 7c 24 18	 mov	 QWORD PTR [rsp+24], rdi
  0000f	41 56		 push	 r14
  00011	48 83 ec 50	 sub	 rsp, 80			; 00000050H
  00015	48 8b 05 00 00
	00 00		 mov	 rax, QWORD PTR __security_cookie
  0001c	48 33 c4	 xor	 rax, rsp
  0001f	48 89 44 24 40	 mov	 QWORD PTR __$ArrayPad$[rsp], rax
  00024	48 8b fa	 mov	 rdi, rdx
  00027	48 8b d9	 mov	 rbx, rcx

; 174  :     __m256i* retPtr = _aligned_malloc(sizeof(__m256i), sizeof(__m256i));

  0002a	ba 20 00 00 00	 mov	 edx, 32			; 00000020H
  0002f	4d 8b f1	 mov	 r14, r9
  00032	8b ca		 mov	 ecx, edx
  00034	49 8b f0	 mov	 rsi, r8
  00037	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 175  : 
; 176  :     uint64_t ptr[4] = {c0,c1,c2,c3 };

  0003d	48 89 5c 24 20	 mov	 QWORD PTR ptr$[rsp], rbx
  00042	48 89 7c 24 28	 mov	 QWORD PTR ptr$[rsp+8], rdi
  00047	48 89 74 24 30	 mov	 QWORD PTR ptr$[rsp+16], rsi
  0004c	4c 89 74 24 38	 mov	 QWORD PTR ptr$[rsp+24], r14

; 177  : 
; 178  :     if (NULL != retPtr)

  00051	48 85 c0	 test	 rax, rax
  00054	74 0d		 je	 SHORT $LN4@load_matma

; 179  :     {
; 180  :         *retPtr = _mm256_loadu_epi64(&ptr);

  00056	c5 fe 6f 44 24
	20		 vmovdqu ymm0, YMMWORD PTR ptr$[rsp]
  0005c	c5 fe 7f 00	 vmovdqu YMMWORD PTR [rax], ymm0
  00060	c5 f8 77	 vzeroupper
$LN4@load_matma:

; 181  :     }
; 182  : 
; 183  :     return retPtr;
; 184  : 
; 185  : }

  00063	48 8b 4c 24 40	 mov	 rcx, QWORD PTR __$ArrayPad$[rsp]
  00068	48 33 cc	 xor	 rcx, rsp
  0006b	e8 00 00 00 00	 call	 __security_check_cookie
  00070	48 8b 5c 24 60	 mov	 rbx, QWORD PTR [rsp+96]
  00075	48 8b 74 24 68	 mov	 rsi, QWORD PTR [rsp+104]
  0007a	48 8b 7c 24 70	 mov	 rdi, QWORD PTR [rsp+112]
  0007f	48 83 c4 50	 add	 rsp, 80			; 00000050H
  00083	41 5e		 pop	 r14
  00085	c3		 ret	 0
load_matmap ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT tranpose_4x4matmap
_TEXT	SEGMENT
matPtr$ = 48
tranpose_4x4matmap PROC					; COMDAT

; 188  : {

$LN6:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	48 89 7c 24 18	 mov	 QWORD PTR [rsp+24], rdi
  0000f	4c 89 74 24 20	 mov	 QWORD PTR [rsp+32], r14
  00014	41 57		 push	 r15
  00016	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 189  : 
; 190  :     __m256i* ret = _aligned_malloc(sizeof(__m256i),sizeof(__m256i));

  0001a	ba 20 00 00 00	 mov	 edx, 32			; 00000020H
  0001f	48 8b f1	 mov	 rsi, rcx
  00022	8b ca		 mov	 ecx, edx
  00024	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 191  : 
; 192  :     printf("%llu\n",(uint64_t)ret);

  0002a	48 8b d0	 mov	 rdx, rax
  0002d	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:??_C@_05JMLLFKBP@?$CFllu?6@
  00034	48 8b d8	 mov	 rbx, rax
  00037	e8 00 00 00 00	 call	 printf

; 193  : 
; 194  :     __m128* columPtr[4];
; 195  :     columPtr[0] = _aligned_malloc(sizeof(__m128),16);

  0003c	ba 10 00 00 00	 mov	 edx, 16
  00041	8b ca		 mov	 ecx, edx
  00043	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 196  :     columPtr[1] = _aligned_malloc(sizeof(__m128),16);

  00049	ba 10 00 00 00	 mov	 edx, 16
  0004e	48 8b f8	 mov	 rdi, rax
  00051	8b ca		 mov	 ecx, edx
  00053	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 197  :     columPtr[2] = _aligned_malloc(sizeof(__m128),16);

  00059	ba 10 00 00 00	 mov	 edx, 16
  0005e	4c 8b f0	 mov	 r14, rax
  00061	8b ca		 mov	 ecx, edx
  00063	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 198  :     columPtr[3] = _aligned_malloc(sizeof(__m128),16);

  00069	ba 10 00 00 00	 mov	 edx, 16
  0006e	4c 8b f8	 mov	 r15, rax
  00071	8b ca		 mov	 ecx, edx
  00073	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc
  00079	48 8b d0	 mov	 rdx, rax

; 199  : 
; 200  :     if (NULL != ret)

  0007c	48 85 db	 test	 rbx, rbx
  0007f	74 0b		 je	 SHORT $LN2@tranpose_4

; 201  :     {
; 202  :         *ret = _mm256_loadu_epi64(*(uint64_t*)&columPtr);

  00081	c5 fe 6f 07	 vmovdqu ymm0, YMMWORD PTR [rdi]
  00085	c5 fe 7f 03	 vmovdqu YMMWORD PTR [rbx], ymm0
  00089	c5 f8 77	 vzeroupper
$LN2@tranpose_4:

; 203  :     }
; 204  : 
; 205  :     __m128* c0Ptr = (__m128*) (matPtr->m256i_i64[0]);

  0008c	48 8b 0e	 mov	 rcx, QWORD PTR [rsi]

; 206  :     __m128* c1Ptr = (__m128*) (matPtr->m256i_i64[1]);
; 207  :     __m128* c2Ptr = (__m128*)(matPtr->m256i_i64[2]);

  0008f	48 8b 46 10	 mov	 rax, QWORD PTR [rsi+16]

; 208  :     __m128* c3Ptr = (__m128*)(matPtr->m256i_i64[3]);
; 209  : 
; 210  :     __m128 cache0Ptr = _mm_shuffle_ps(*c0Ptr,*c1Ptr,0b00010001);

  00093	0f 10 21	 movups	 xmm4, XMMWORD PTR [rcx]

; 211  :     __m128 cache1Ptr = _mm_shuffle_ps(*c0Ptr,*c1Ptr,0b01110111);
; 212  :     __m128 cache2Ptr = _mm_shuffle_ps(*c2Ptr, *c3Ptr, 0b00010001);

  00096	0f 10 10	 movups	 xmm2, XMMWORD PTR [rax]
  00099	0f 28 dc	 movaps	 xmm3, xmm4
  0009c	48 8b 46 18	 mov	 rax, QWORD PTR [rsi+24]
  000a0	0f 28 ca	 movaps	 xmm1, xmm2
  000a3	48 8b 4e 08	 mov	 rcx, QWORD PTR [rsi+8]

; 213  :     __m128 cache3Ptr = _mm_shuffle_ps(*c2Ptr, *c3Ptr, 0b01110111);
; 214  : 
; 215  :     *(columPtr[0]) = _mm_shuffle_ps(cache0Ptr, cache2Ptr, 0b00100010);
; 216  :     *(columPtr[1]) = _mm_shuffle_ps(cache0Ptr, cache2Ptr, 0b01110111);
; 217  :     *(columPtr[2]) = _mm_shuffle_ps(cache1Ptr, cache3Ptr, 0b00100010);
; 218  :     *(columPtr[3]) = _mm_shuffle_ps(cache1Ptr, cache3Ptr, 0b01110111);
; 219  : 
; 220  :     return ret;
; 221  : }

  000a7	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  000ac	0f c6 08 11	 shufps	 xmm1, XMMWORD PTR [rax], 17
  000b0	0f c6 10 77	 shufps	 xmm2, XMMWORD PTR [rax], 119 ; 00000077H
  000b4	48 8b c3	 mov	 rax, rbx
  000b7	0f c6 19 11	 shufps	 xmm3, XMMWORD PTR [rcx], 17
  000bb	0f c6 21 77	 shufps	 xmm4, XMMWORD PTR [rcx], 119 ; 00000077H
  000bf	0f 28 c3	 movaps	 xmm0, xmm3
  000c2	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  000c7	0f c6 c1 22	 shufps	 xmm0, xmm1, 34		; 00000022H
  000cb	0f 11 07	 movups	 XMMWORD PTR [rdi], xmm0
  000ce	0f 28 c4	 movaps	 xmm0, xmm4
  000d1	48 8b 7c 24 40	 mov	 rdi, QWORD PTR [rsp+64]
  000d6	0f c6 d9 77	 shufps	 xmm3, xmm1, 119		; 00000077H
  000da	41 0f 11 1e	 movups	 XMMWORD PTR [r14], xmm3
  000de	4c 8b 74 24 48	 mov	 r14, QWORD PTR [rsp+72]
  000e3	0f c6 c2 22	 shufps	 xmm0, xmm2, 34		; 00000022H
  000e7	0f c6 e2 77	 shufps	 xmm4, xmm2, 119		; 00000077H
  000eb	41 0f 11 07	 movups	 XMMWORD PTR [r15], xmm0
  000ef	0f 11 22	 movups	 XMMWORD PTR [rdx], xmm4
  000f2	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000f6	41 5f		 pop	 r15
  000f8	c3		 ret	 0
tranpose_4x4matmap ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT set_m128ptr_default
_TEXT	SEGMENT
set_m128ptr_default PROC				; COMDAT

; 225  :     return defaultVecPtr;

  00000	48 8b 05 00 00
	00 00		 mov	 rax, QWORD PTR defaultVecPtr

; 226  : }

  00007	c3		 ret	 0
set_m128ptr_default ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT transpose_ssemat_2
_TEXT	SEGMENT
matPtr$ = 48
transpose_ssemat_2 PROC					; COMDAT

; 229  : {

$LN11:
  00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
  00005	48 89 74 24 10	 mov	 QWORD PTR [rsp+16], rsi
  0000a	57		 push	 rdi
  0000b	48 83 ec 20	 sub	 rsp, 32			; 00000020H

; 230  :     __m128* colum0ptr = _aligned_malloc(sizeof(__m128), 16);

  0000f	ba 10 00 00 00	 mov	 edx, 16
  00014	48 8b d9	 mov	 rbx, rcx
  00017	8b ca		 mov	 ecx, edx
  00019	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 231  :     __m128* colum1ptr = _aligned_malloc(sizeof(__m128), 16);

  0001f	ba 10 00 00 00	 mov	 edx, 16
  00024	48 8b f0	 mov	 rsi, rax
  00027	8b ca		 mov	 ecx, edx
  00029	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc

; 232  :     sse_matmap* ret = malloc(sizeof(sse_matmap));

  0002f	b9 20 00 00 00	 mov	 ecx, 32			; 00000020H
  00034	48 8b f8	 mov	 rdi, rax
  00037	ff 15 00 00 00
	00		 call	 QWORD PTR __imp_malloc

; 233  : 
; 234  :     __m128 t0 = _mm_shuffle_ps(*(matPtr->c0ptr), *(matPtr->c1ptr), 0b00010001);

  0003d	48 8b 0b	 mov	 rcx, QWORD PTR [rbx]
  00040	4c 8b c0	 mov	 r8, rax
  00043	48 8b 53 08	 mov	 rdx, QWORD PTR [rbx+8]
  00047	0f 10 09	 movups	 xmm1, XMMWORD PTR [rcx]
  0004a	0f 10 12	 movups	 xmm2, XMMWORD PTR [rdx]

; 235  :     __m128 t1 = _mm_shuffle_ps(*(matPtr->c1ptr), *(matPtr->c3ptr), 0b00010001);

  0004d	48 8b 4b 18	 mov	 rcx, QWORD PTR [rbx+24]
  00051	0f c6 ca 11	 shufps	 xmm1, xmm2, 17
  00055	0f c6 11 11	 shufps	 xmm2, XMMWORD PTR [rcx], 17

; 236  : 
; 237  :     if (NULL != colum0ptr)

  00059	48 85 f6	 test	 rsi, rsi
  0005c	74 0a		 je	 SHORT $LN2@transpose_

; 238  :     {
; 239  :         *colum0ptr = _mm_shuffle_ps(t0, t1, 0b00100010);

  0005e	0f 28 c1	 movaps	 xmm0, xmm1
  00061	0f c6 c2 22	 shufps	 xmm0, xmm2, 34		; 00000022H
  00065	0f 11 06	 movups	 XMMWORD PTR [rsi], xmm0
$LN2@transpose_:

; 240  :     }
; 241  :     if (NULL != colum1ptr)

  00068	48 85 ff	 test	 rdi, rdi
  0006b	74 07		 je	 SHORT $LN3@transpose_

; 242  :     {
; 243  :         *colum1ptr = _mm_shuffle_ps(t0, t1, 0b01110111);

  0006d	0f c6 ca 77	 shufps	 xmm1, xmm2, 119		; 00000077H
  00071	0f 11 0f	 movups	 XMMWORD PTR [rdi], xmm1
$LN3@transpose_:

; 244  :     }
; 245  : 
; 246  :     if (NULL != ret)

  00074	4d 85 c0	 test	 r8, r8
  00077	74 19		 je	 SHORT $LN4@transpose_

; 247  :     {
; 248  :         ret->c0ptr = colum0ptr;

  00079	48 89 30	 mov	 QWORD PTR [rax], rsi

; 249  :         ret->c1ptr = colum1ptr;

  0007c	48 89 78 08	 mov	 QWORD PTR [rax+8], rdi

; 250  :         ret->c2ptr = defaultVecPtr;

  00080	48 8b 05 00 00
	00 00		 mov	 rax, QWORD PTR defaultVecPtr
  00087	49 89 40 10	 mov	 QWORD PTR [r8+16], rax

; 251  :         ret->c3ptr = defaultVecPtr;

  0008b	49 89 40 18	 mov	 QWORD PTR [r8+24], rax

; 252  :     }
; 253  : 
; 254  :     return ret;

  0008f	49 8b c0	 mov	 rax, r8
$LN4@transpose_:

; 255  : 
; 256  : 
; 257  : }

  00092	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00097	48 8b 74 24 38	 mov	 rsi, QWORD PTR [rsp+56]
  0009c	48 83 c4 20	 add	 rsp, 32			; 00000020H
  000a0	5f		 pop	 rdi
  000a1	c3		 ret	 0
transpose_ssemat_2 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT deinitM128
_TEXT	SEGMENT
ptr$ = 8
deinitM128 PROC						; COMDAT

; 274  :     free(ptr);

  00000	48 ff 25 00 00
	00 00		 rex_jmp QWORD PTR __imp_free
deinitM128 ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT deinit_matmap_sse
_TEXT	SEGMENT
mapptr$ = 8
deinit_matmap_sse PROC					; COMDAT

; 279  :     free(mapptr);

  00000	48 ff 25 00 00
	00 00		 rex_jmp QWORD PTR __imp_free
deinit_matmap_sse ENDP
_TEXT	ENDS
END