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

include listing.inc

INCLUDELIB MSVCRT
INCLUDELIB OLDNAMES

_DATA	SEGMENT
COMM	sseFunc:BYTE:018H
COMM	pack:BYTE:038H
_DATA	ENDS
msvcjmc	SEGMENT
__E7EC9AD1_concurrencysal@h DB 01H
__ADCB3D40_sal@h DB 01H
__63527AC6_vadefs@h DB 01H
__979672E1_vcruntime@h DB 01H
__1B5F14A0_stdint@h DB 01H
__018B5678_khrplatform@h DB 01H
__79FC18F0_glad@h DB 01H
__B193B045_corecrt@h DB 01H
__887B5571_stddef@h DB 01H
__986CAB3E_glfw3@h DB 01H
__C508448F_StgSharpGraphic@h DB 01H
__B45635C8_mmintrin@h DB 01H
__FF268430_corecrt_malloc@h DB 01H
__61F92E22_malloc@h DB 01H
__17431EB5_xmmintrin@h DB 01H
__203A43BB_SSGinternal@h DB 01H
__D0E9C0B0_corecrt_stdio_config@h DB 01H
__119849BB_corecrt_wstdio@h DB 01H
__2BEDEB13_stdio@h DB 01H
__70BD074A_stdalign@h DB 01H
__72219779_emmintrin@h DB 01H
__AD80FFF0_pmmintrin@h DB 01H
__B5461FF6_linear@c DB 01H
msvcjmc	ENDS
PUBLIC	load
PUBLIC	addps
PUBLIC	subps
PUBLIC	mulps_const
PUBLIC	mulps
PUBLIC	mulps_sum
PUBLIC	divps_const
PUBLIC	divps
PUBLIC	deinitM128
PUBLIC	__JustMyCode_Default
EXTRN	__imp_free:PROC
EXTRN	__imp__aligned_malloc:PROC
EXTRN	__CheckForDebuggerJustMyCode:PROC
EXTRN	_fltused:DWORD
;	COMDAT pdata
pdata	SEGMENT
$pdata$load DD	imagerel $LN6
	DD	imagerel $LN6+140
	DD	imagerel $unwind$load
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$addps DD	imagerel $LN6
	DD	imagerel $LN6+85
	DD	imagerel $unwind$addps
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$subps DD	imagerel $LN6
	DD	imagerel $LN6+85
	DD	imagerel $unwind$subps
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$mulps_const DD imagerel $LN6
	DD	imagerel $LN6+94
	DD	imagerel $unwind$mulps_const
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$mulps DD	imagerel $LN6
	DD	imagerel $LN6+84
	DD	imagerel $unwind$mulps
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$mulps_sum DD imagerel $LN4
	DD	imagerel $LN4+53
	DD	imagerel $unwind$mulps_sum
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$divps_const DD imagerel $LN6
	DD	imagerel $LN6+97
	DD	imagerel $unwind$divps_const
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$divps DD	imagerel $LN6
	DD	imagerel $LN6+84
	DD	imagerel $unwind$divps
pdata	ENDS
;	COMDAT pdata
pdata	SEGMENT
$pdata$deinitM128 DD imagerel $LN4
	DD	imagerel $LN4+36
	DD	imagerel $unwind$deinitM128
pdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$deinitM128 DD 020601H
	DD	030023206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$divps DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$divps_const DD 040b01H
	DD	03680bH
	DD	030027206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$mulps_sum DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$mulps DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$mulps_const DD 040b01H
	DD	03680bH
	DD	030027206H
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$subps DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$addps DD 040a01H
	DD	06340aH
	DD	07006320aH
xdata	ENDS
;	COMDAT xdata
xdata	SEGMENT
$unwind$load DD	092701H
	DD	039827H
	DD	04881eH
	DD	057815H
	DD	066809H
	DD	0e204H
xdata	ENDS
; Function compile flags: /Odt
;	COMDAT __JustMyCode_Default
_TEXT	SEGMENT
__JustMyCode_Default PROC				; COMDAT
  00000	c2 00 00	 ret	 0
__JustMyCode_Default ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT deinitM128
_TEXT	SEGMENT
ptr$ = 48
deinitM128 PROC						; COMDAT

; 142  : {

$LN4:
  00000	40 53		 push	 rbx
  00002	48 83 ec 20	 sub	 rsp, 32			; 00000020H
  00006	48 8b d9	 mov	 rbx, rcx
  00009	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00010	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  00015	48 8b cb	 mov	 rcx, rbx

; 143  :     free(ptr);
; 144  : }

  00018	48 83 c4 20	 add	 rsp, 32			; 00000020H
  0001c	5b		 pop	 rbx
  0001d	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 divps
_TEXT	SEGMENT
ptr1$ = 48
ptr2$ = 56
divps	PROC						; COMDAT

; 120  : {

$LN6:
  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 f9	 mov	 rdi, rcx
  0000d	48 8b da	 mov	 rbx, rdx
  00010	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00017	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  0001c	ba 10 00 00 00	 mov	 edx, 16
  00021	8b ca		 mov	 ecx, edx
  00023	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc
  00029	48 85 c0	 test	 rax, rax
  0002c	74 14		 je	 SHORT $LN2@divps

; 121  :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
; 122  : 
; 123  :     if (NULL != ret)
; 124  :     {
; 125  :         *ret = _mm_div_ps(*ptr1, *ptr2);

  0002e	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00031	0f 5e 03	 divps	 xmm0, XMMWORD PTR [rbx]
  00034	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 126  :         return ret;
; 127  :     }
; 128  :     else
; 129  :     {
; 130  :         return -1;
; 131  :     }
; 132  : }

  00037	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0003c	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00040	5f		 pop	 rdi
  00041	c3		 ret	 0
$LN2@divps:
  00042	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00047	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  0004e	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00052	5f		 pop	 rdi
  00053	c3		 ret	 0
divps	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$ = 80
value$ = 88
divps_const PROC					; COMDAT

; 101  : {

$LN6:
  00000	40 53		 push	 rbx
  00002	48 83 ec 40	 sub	 rsp, 64			; 00000040H
  00006	0f 29 74 24 30	 movaps	 XMMWORD PTR [rsp+48], xmm6
  0000b	48 8b d9	 mov	 rbx, rcx
  0000e	0f 28 f1	 movaps	 xmm6, xmm1
  00011	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00018	0f c6 f6 00	 shufps	 xmm6, xmm6, 0
  0001c	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  00021	ba 10 00 00 00	 mov	 edx, 16
  00026	8b ca		 mov	 ecx, edx
  00028	0f 11 74 24 20	 movups	 XMMWORD PTR c$[rsp], xmm6
  0002d	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc
  00033	48 85 c0	 test	 rax, rax
  00036	74 17		 je	 SHORT $LN2@divps_cons

; 102  : 
; 103  :     float c[4] = { value, value, value, value };
; 104  :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
; 105  : 
; 106  :     __m128 valueVec = _mm_loadu_ps(&c);
; 107  : 
; 108  :     if (NULL != ret)
; 109  :     {
; 110  :         *ret = _mm_div_ps(*ptr, valueVec);

  00038	0f 10 0b	 movups	 xmm1, XMMWORD PTR [rbx]
  0003b	0f 10 c6	 movups	 xmm0, xmm6
  0003e	0f 5e ce	 divps	 xmm1, xmm6
  00041	0f 11 08	 movups	 XMMWORD PTR [rax], xmm1

; 111  :         return ret;
; 112  :     }
; 113  :     else
; 114  :     {
; 115  :         return -1;
; 116  :     }
; 117  : }

  00044	0f 28 74 24 30	 movaps	 xmm6, XMMWORD PTR [rsp+48]
  00049	48 83 c4 40	 add	 rsp, 64			; 00000040H
  0004d	5b		 pop	 rbx
  0004e	c3		 ret	 0
$LN2@divps_cons:
  0004f	0f 28 74 24 30	 movaps	 xmm6, XMMWORD PTR [rsp+48]
  00054	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  0005b	48 83 c4 40	 add	 rsp, 64			; 00000040H
  0005f	5b		 pop	 rbx
  00060	c3		 ret	 0
divps_const ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT mulps_sum
_TEXT	SEGMENT
ptr1$ = 48
ptr2$ = 56
mulps_sum PROC						; COMDAT

; 93   : {

$LN4:
  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 d9	 mov	 rbx, rcx
  0000d	48 8b fa	 mov	 rdi, rdx
  00010	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00017	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  0001c	0f 10 03	 movups	 xmm0, XMMWORD PTR [rbx]
  0001f	0f 59 07	 mulps	 xmm0, XMMWORD PTR [rdi]
  00022	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00027	f2 0f 7c c0	 haddps	 xmm0, xmm0
  0002b	f2 0f 7c c0	 haddps	 xmm0, xmm0

; 94   :     __m128 ret = _mm_mul_ps(*ptr1,*ptr2);
; 95   :     ret = _mm_hadd_ps(ret,ret);
; 96   :     ret = _mm_hadd_ps(ret,ret);
; 97   :     return *(float*)&ret;
; 98   : }

  0002f	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00033	5f		 pop	 rdi
  00034	c3		 ret	 0
mulps_sum 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

; 78   : {

$LN6:
  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 f9	 mov	 rdi, rcx
  0000d	48 8b da	 mov	 rbx, rdx
  00010	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00017	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  0001c	ba 10 00 00 00	 mov	 edx, 16
  00021	8b ca		 mov	 ecx, edx
  00023	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc
  00029	48 85 c0	 test	 rax, rax
  0002c	74 14		 je	 SHORT $LN2@mulps

; 79   :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
; 80   : 
; 81   :     if (NULL != ret)
; 82   :     {
; 83   :         *ret = _mm_mul_ps(*ptr1, *ptr2);

  0002e	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00031	0f 59 03	 mulps	 xmm0, XMMWORD PTR [rbx]
  00034	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 84   :         return ret;
; 85   :     }
; 86   :     else
; 87   :     {
; 88   :         return -1;
; 89   :     }
; 90   : }

  00037	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0003c	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00040	5f		 pop	 rdi
  00041	c3		 ret	 0
$LN2@mulps:
  00042	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00047	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  0004e	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00052	5f		 pop	 rdi
  00053	c3		 ret	 0
mulps	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$ = 80
value$ = 88
mulps_const PROC					; COMDAT

; 60   : {

$LN6:
  00000	40 53		 push	 rbx
  00002	48 83 ec 40	 sub	 rsp, 64			; 00000040H
  00006	0f 29 74 24 30	 movaps	 XMMWORD PTR [rsp+48], xmm6
  0000b	48 8b d9	 mov	 rbx, rcx
  0000e	0f 28 f1	 movaps	 xmm6, xmm1
  00011	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00018	0f c6 f6 00	 shufps	 xmm6, xmm6, 0
  0001c	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  00021	ba 10 00 00 00	 mov	 edx, 16
  00026	8b ca		 mov	 ecx, edx
  00028	0f 11 74 24 20	 movups	 XMMWORD PTR c$[rsp], xmm6
  0002d	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc
  00033	48 85 c0	 test	 rax, rax
  00036	74 14		 je	 SHORT $LN2@mulps_cons

; 61   :     float c[4] = { value, value, value, value };
; 62   :     __m128* ret = _aligned_malloc(sizeof(__m128),16);
; 63   : 
; 64   :     __m128 valueVec = _mm_loadu_ps(&c);
; 65   : 
; 66   :     if (NULL != ret)
; 67   :     {
; 68   :         *ret = _mm_mul_ps(*ptr,valueVec);

  00038	0f 10 c6	 movups	 xmm0, xmm6
  0003b	0f 59 03	 mulps	 xmm0, XMMWORD PTR [rbx]
  0003e	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 69   :         return ret;
; 70   :     }
; 71   :     else
; 72   :     {
; 73   :         return -1;
; 74   :     }
; 75   : }

  00041	0f 28 74 24 30	 movaps	 xmm6, XMMWORD PTR [rsp+48]
  00046	48 83 c4 40	 add	 rsp, 64			; 00000040H
  0004a	5b		 pop	 rbx
  0004b	c3		 ret	 0
$LN2@mulps_cons:
  0004c	0f 28 74 24 30	 movaps	 xmm6, XMMWORD PTR [rsp+48]
  00051	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  00058	48 83 c4 40	 add	 rsp, 64			; 00000040H
  0005c	5b		 pop	 rbx
  0005d	c3		 ret	 0
mulps_const 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

; 45   : {

$LN6:
  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 f9	 mov	 rdi, rcx
  0000d	48 8b da	 mov	 rbx, rdx
  00010	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00017	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  0001c	ba 10 00 00 00	 mov	 edx, 16
  00021	8d 4a f8	 lea	 ecx, QWORD PTR [rdx-8]
  00024	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc
  0002a	48 85 c0	 test	 rax, rax
  0002d	74 14		 je	 SHORT $LN2@subps

; 46   :     __m128* ret = _aligned_malloc(sizeof(__m128*), 16);
; 47   : 
; 48   :     if (NULL != ret)
; 49   :     {
; 50   :         *ret = _mm_sub_ps(*ptr1, *ptr2);

  0002f	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00032	0f 5c 03	 subps	 xmm0, XMMWORD PTR [rbx]
  00035	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 51   :         return ret;
; 52   :     }
; 53   :     else
; 54   :     {
; 55   :         return -1;
; 56   :     }
; 57   : }

  00038	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0003d	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00041	5f		 pop	 rdi
  00042	c3		 ret	 0
$LN2@subps:
  00043	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00048	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  0004f	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00053	5f		 pop	 rdi
  00054	c3		 ret	 0
subps	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

; 28   : {

$LN6:
  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 f9	 mov	 rdi, rcx
  0000d	48 8b da	 mov	 rbx, rdx
  00010	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00017	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  0001c	ba 10 00 00 00	 mov	 edx, 16
  00021	8d 4a f8	 lea	 ecx, QWORD PTR [rdx-8]
  00024	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc
  0002a	48 85 c0	 test	 rax, rax
  0002d	74 14		 je	 SHORT $LN2@addps

; 29   :     
; 30   :     __m128* ret = _aligned_malloc(sizeof(__m128*),16);
; 31   : 
; 32   :     if (NULL != ret)
; 33   :     {
; 34   :         *ret = _mm_add_ps(*ptr1, *ptr2);

  0002f	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
  00032	0f 58 03	 addps	 xmm0, XMMWORD PTR [rbx]
  00035	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 35   :         return ret;
; 36   :     }
; 37   :     else
; 38   :     {
; 39   :         return -1;
; 40   :     }
; 41   : 
; 42   : }

  00038	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  0003d	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00041	5f		 pop	 rdi
  00042	c3		 ret	 0
$LN2@addps:
  00043	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
  00048	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
  0004f	48 83 c4 20	 add	 rsp, 32			; 00000020H
  00053	5f		 pop	 rdi
  00054	c3		 ret	 0
addps	ENDP
_TEXT	ENDS
; Function compile flags: /Ogtpy
; File D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c
;	COMDAT load
_TEXT	SEGMENT
array$ = 32
x$ = 128
y$ = 136
z$ = 144
w$ = 152
load	PROC						; COMDAT

; 12   : {

$LN6:
  00000	48 83 ec 78	 sub	 rsp, 120		; 00000078H
  00004	0f 29 74 24 60	 movaps	 XMMWORD PTR [rsp+96], xmm6
  00009	48 8d 0d 00 00
	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
  00010	0f 29 7c 24 50	 movaps	 XMMWORD PTR [rsp+80], xmm7
  00015	0f 28 f0	 movaps	 xmm6, xmm0
  00018	44 0f 29 44 24
	40		 movaps	 XMMWORD PTR [rsp+64], xmm8
  0001e	0f 28 f9	 movaps	 xmm7, xmm1
  00021	44 0f 29 4c 24
	30		 movaps	 XMMWORD PTR [rsp+48], xmm9
  00027	44 0f 28 c2	 movaps	 xmm8, xmm2
  0002b	44 0f 28 cb	 movaps	 xmm9, xmm3
  0002f	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
  00034	ba 10 00 00 00	 mov	 edx, 16
  00039	f3 0f 11 74 24
	20		 movss	 DWORD PTR array$[rsp], xmm6
  0003f	8b ca		 mov	 ecx, edx
  00041	f3 0f 11 7c 24
	24		 movss	 DWORD PTR array$[rsp+4], xmm7
  00047	f3 44 0f 11 44
	24 28		 movss	 DWORD PTR array$[rsp+8], xmm8
  0004e	f3 44 0f 11 4c
	24 2c		 movss	 DWORD PTR array$[rsp+12], xmm9
  00055	ff 15 00 00 00
	00		 call	 QWORD PTR __imp__aligned_malloc
  0005b	48 85 c0	 test	 rax, rax
  0005e	74 0a		 je	 SHORT $LN2@load

; 13   :     float array[4] = {x,y,z,w};
; 14   :     __m128* ptr = _aligned_malloc(sizeof(__m128),16);
; 15   : 
; 16   :     if (NULL != ptr)
; 17   :     {
; 18   :         *ptr = _mm_loadu_ps(&array);

  00060	0f 10 44 24 20	 movups	 xmm0, XMMWORD PTR array$[rsp]
  00065	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0

; 19   :         return ptr;

  00068	eb 07		 jmp	 SHORT $LN3@load
$LN2@load:

; 20   :     }
; 21   :     else
; 22   :     {
; 23   :         return -1;

  0006a	48 c7 c0 ff ff
	ff ff		 mov	 rax, -1
$LN3@load:

; 24   :     }
; 25   : }

  00071	0f 28 74 24 60	 movaps	 xmm6, XMMWORD PTR [rsp+96]
  00076	0f 28 7c 24 50	 movaps	 xmm7, XMMWORD PTR [rsp+80]
  0007b	44 0f 28 44 24
	40		 movaps	 xmm8, XMMWORD PTR [rsp+64]
  00081	44 0f 28 4c 24
	30		 movaps	 xmm9, XMMWORD PTR [rsp+48]
  00087	48 83 c4 78	 add	 rsp, 120		; 00000078H
  0008b	c3		 ret	 0
load	ENDP
_TEXT	ENDS
END