LabAssignment.asm

; -------------------------------------------------------------------------------------	;
;	Ëàáîðàòîðíàÿ ðàáîòà ¹2 ïî êóðñó "Ïðîãðàììèðîâàíèå íà ÿçûêå àññåìáëåðà"				;
;	Âàðèàíò ¹1.2																		;
;	Âûïîëíèë ñòóäåíò Ìàêååâ Âëàäèñëàâ													;
;																						;
;	Èñõîäíûé ìîäóëü LabAssignment.asm													;
;	Ñîäåðæèò ôóíêöèè íà ÿçûêå àññåìáëåðà, ðàçðàáîòàííûå â ñîîòâåòñòâèè ñ çàäàíèåì		;
; -------------------------------------------------------------------------------------	;
;	Çàäàíèå: Ðåàëèçîâàòü ïðÿìîå è îáðàòíîå ïðåîáðàçîâàíèÿ Ôóðüå
;	Ôîðìàò äàííûõ ñèãíàëà: __int8
;	Ôîðìàò äàííûõ ñïåêòðà: float
;	Ðàçìåð (êîëè÷åñòâî îòñ÷åòîâ) ñèãíàëà è ñïåêòðà: 8
;	Ñïîñîá ðåàëèçàöèè: DFT 2x2 + 2 áàáî÷êè
;	Îòñ÷åòû ñïåêòðà ÿâëÿþòñÿ êîìïëåêñíûìè ÷èñëàìè. Ïðè÷åì äåéñòâèòåëüíûå ÷àñòè õðàíÿòñÿ
;	â ïåðâîé ïîëîâèíå ìàññèâà, à ìíèìûå - âî âòîðîé

.DATA
	; Âåêòîðà-ìíîæèòåëè äëÿ âûáîðà íàïðàâëåíèÿ Spectrum <-> Signal
	NormalMV	dword	3f800000h
				dword	3f800000h
				dword	3f800000h
				dword	3f800000h
				dword	3f800000h
				dword	3f800000h
				dword	3f800000h
				dword	3f800000h
	ImMV		dword	3f800000h
				dword	3f800000h
				dword	3f800000h
				dword	3f800000h
				dword	0bf800000h
				dword	0bf800000h
				dword	0bf800000h
				dword	0bf800000h
	XImMV		dword	0bf800000h
				dword	0bf800000h
				dword	3f800000h
				dword	3f800000h
				dword	0bf800000h
				dword	0bf800000h
				dword	0bf800000h
				dword	0bf800000h
	; Âåêòîðà-ìíîæèòåëè äëÿ âåêòîðîâ oU (Âåêòîð O âåðõíåé ÷àñòè áàáî÷êè), oB (Íèæíåé áàáî÷êè) è O
		; ReRMV = < 0, 0, 0, 0,			1, 1, -1, -1 >
	ReRMV		dword 0bf800000h
				dword 0bf800000h
				dword 3f800000h
				dword 3f800000h
				dword 00000000h
				dword 00000000h
				dword 00000000h
				dword 00000000h
		; ImRMV = < -1, -1, 1, 1,			0, 0, 0, 0 >
	ImRMV		dword 00000000h
				dword 00000000h
				dword 00000000h
				dword 00000000h
				dword 3f800000h
				dword 3f800000h
				dword 0bf800000h
				dword 0bf800000h
		; ReIMV = < -1, -1, 1, 1,			0, 0, 0, 0 >
	ReIMV		dword 00000000h
				dword 00000000h
				dword 00000000h
				dword 00000000h
				dword 0bf800000h
				dword 0bf800000h
				dword 3f800000h
				dword 3f800000h
		; XReRMV = < 1, s, 0, -s, -1, -s, 0, s >
	XReRMV	dword	00000000h
				dword	00000000h
				dword	0bf800000h
				dword	3f800000h
				dword	3f3504f3h
				dword	0bf3504f7h
				dword	0bf3504f7h
				dword	3f3504f3h
		; XReIMV = < 0, s, 1, s, 0, -s, -1, -s >
	XReIMV	dword	0bf800000h
				dword	3f800000h
				dword	00000000h
				dword	00000000h
				dword	0bf3504f7h
				dword	3f3504f3h
				dword	0bf3504f7h
				dword	3f3504f3h
		; XImRMV = [ 1, -1, 0, 0, s, -s, s, -s ]
	XImRMV		dword	3f800000h
				dword	0bf800000h
				dword	00000000h
				dword	00000000h
				dword	3f3504f3h
				dword	0bf3504f7h
				dword	3f3504f3h
				dword	0bf3504f7h
	; Âåêòîð ÷èñåë 1/8
	const18		dword	3e000000h
				dword	3e000000h
				dword	3e000000h
				dword	3e000000h
				dword	3e000000h
				dword	3e000000h
				dword	3e000000h
				dword	3e000000h

.CODE

ProcessLOandLE PROC							;
											; ymm0/1=Re/Im	@ x3/7,x2/6,x1/5,x0/4
	vaddps xmm2, xmm0, xmm1					; ymm2 = Re/Im	@ o0b, o0u, e0b, e0u,	0, 0, 0, 0
	vsubps xmm3, xmm0, xmm1					; ymm3 = Re/Im	@ o1b, o1u, e1b, e1u,	0, 0, 0, 0
	vperm2f128 ymm4, ymm2, ymm3, 00100000b	; ymm4 = Re/Im	@ o0B, o0U, e0B, e0U,	o1B, o1U, e1B, e1U
	vpermilps ymm5, ymm4, 00010001b			; ymm5 = Re/Im	@ o0U, o0B, o0U, o0B,	o1U, o1B, o1U, o1B
	vpermilps ymm6, ymm4, 10111011b			; ymm6 = Re/Im	@ e0U, e0B, e0U, e0B,	e1U, e1B, e1U, e1B
	ret
ProcessLOandLE ENDP

FourierTransform PROC	; Âñïîìîãàòåëüíàÿ ôóíêöèÿ, ñîäåðæàùàÿ îáùèå äëÿ âû÷èñëåíèÿ ñïåêòðà è ñèãíàëà ìåòîäû
		; [RCX]- ðåçóëüòèðóþùèé âåêòîð
		; Îáîçíà÷åíèÿ:
		;	e[i]- âåðõíèé âåêòîð äëèíû 4
		;	o[i]- íèæíèé âåêòîð äëèíû 4
		;	E[i]- âåðõíèé âåêòîð äëèíû 8
		;	O[i]- íèæíèé âåêòîð äëèíû 8
		
		; Ñèìâîë @ îáîçíà÷àåò òî æå, ÷òî è ïàðà { [, ] } ñ òåì ðàçëè÷èåì,
		;	÷òî ýëåìåíòû îòîáðàæàþòñÿ â îáðàòíîì ïîðÿäêå
		; ymm0 = Re @ x3, x2, x1, x0, 0, 0, 0, 0
		; ymm1 = Re @ x7, x6, x5, x4, 0, 0, 0, 0
		; ymm12 = [ 0 .. Im(x3..x0)]
		; ymm14 = [ 0 .. Im(x7..x4)]
	sub RSP, 4 * 8 * 2 * 2;
	call ProcessLOandLE; Âûçîâ ôóíêöèè âû÷èñëåíèÿ Re(o-s, e-s)
	vmovups ymm7, ymm5	; ymm7 = [ Re(o1B, o1U, o1B, o1U,	o0B, o0U, o0B, o0U ) ]
	vmovups ymm8, ymm6	; ymm8 = [ Re(e1B, e1U, e1B, e1U,	e0B, e0U, e0B, e0U ) ]
	vmovups ymm0, ymm12;
	vmovups ymm1, ymm14;
	call ProcessLOandLE; Âûçîâ ôóíêöèè âû÷èñëåíèÿ Im(o-s, e-s)
		; ymm5 = Im(o-s)
		; ymm6 = Im(e-s)
		; ymm7 = Re(o-s)
		; ymm8 = Re(e-s)
	; Calculating o*w
	
	vmovups ymm0, [ ReRMV ]	; Çàãðóçêà âåêòîðîâ-ìíîæèòåëåé
	vmovups ymm1, [ ReIMV ]	;
	vmovups ymm2, [ ImRMV ]	;
	
	vmulps ymm1, ymm1, ymm15; Óìíîæåíèå ìíîæèòåëåé Im(MV) íà Sign(Im(w(1, 8))*(-1)
	vmulps ymm2, ymm2, ymm15;
	
	vmulps ymm9, ymm7, ymm0		;
	vmulps ymm10, ymm5, ymm1	;
	vaddps ymm11, ymm9, ymm10	;
		; ymm11 = Re(o-s * w)
	vmulps ymm9, ymm7, ymm2		;
	vmulps ymm10, ymm5, ymm0	; ImIMV = ReRMV
	vaddps ymm12, ymm9, ymm10	;
		; ymm12 = Im(o-s * w)
		
		; ymm12 = Im(o-s * w)
		; ymm6 = Im(e-s)
		; ymm11 = Re(o-s * w)
		; ymm8 = Re(e-s)
	
	vaddps ymm9, ymm8, ymm11			; ymm9 =	Re(O[1], E[1], O[3], E[3], O[0], E[0], O[2], E[2])
	vaddps ymm10, ymm6, ymm12			; ymm10 =	Im(O[1], E[1], O[3], E[3], O[0], E[0], O[2], E[2])

	vpermilps ymm5, ymm9, 10100000b		; ymm5 =	Re(E[1], E[1], E[3], E[3], E[0], E[0], E[2], E[2])
	vpermilps ymm6, ymm10, 10100000b	; ymm6 =	Im(E[1], E[1], E[3], E[3], E[0], E[0], E[2], E[2])
	vpermilps ymm7, ymm9, 11110101b		; ymm7 =	Re(O[1], O[1], O[3], O[3], O[0], O[0], O[2], O[2])
	vpermilps ymm8, ymm10, 11110101b	; ymm8 =	Im(O[1], O[1], O[3], O[3], O[0], O[0], O[2], O[2])

	vmovups ymm0, [ XReRMV ]	;
	vmovups ymm1, [ XReIMV ]	;
	vmovups ymm2, [ XImRMV ]	;
	
	vmulps ymm1, ymm1, ymm13; Óìíîæåíèå ìíîæèòåëåé Im(MV) íà Sign(Im(w(1, 8))*(-1)
	vmulps ymm2, ymm2, ymm13;

	vmulps ymm9, ymm7, ymm0		;
	vmulps ymm10, ymm8, ymm1	;
	vaddps ymm11, ymm9, ymm10	;
		; ymm11 = Re(O-s)

	vmulps ymm9, ymm7, ymm2		;
	vmulps ymm10, ymm8, ymm0	; ImIMV = ReRMV
	vaddps ymm12, ymm9, ymm10	;
		; ymm12 = Im(O-s)
		
		; ymm5 =	Re(E[1], E[1], E[3], E[3], E[0], E[0], E[2], E[2])
		; ymm6 =	Im(E[1], E[1], E[3], E[3], E[0], E[0], E[2], E[2])
		; ymm11 =	Re[ O1, O5, O3, O7, O0, O4, O2, O6 ]
		; ymm12 =	Im[ O1, O5, O3, O7, O0, O4, O2, O6 ]

	vaddps ymm0, ymm5, ymm11;
	vaddps ymm1, ymm6, ymm12;
	vmovups ymmword ptr [RSP], ymm0
	vmovups ymmword ptr [RSP + 4 * 8], ymm1

	; Çàïèñü ðåçóëüòàòîâ
	;	[ 0 1 2 3	4 5 6 7 ] -> [ 6 2 4 0	7 3 5 1 ]
	
	vmovss dword ptr [ RCX + 4 * 6 ], xmm0	;
	vperm2f128 ymm0, ymm0, ymm0, 00000001b	;
	vmovss dword ptr [ RCX + 4 * 7 ], xmm0	;
	vpermilps ymm0, ymm0, 10010011b			;
	vmovss dword ptr [ RCX + 4 * 1 ], xmm0	;
	vperm2f128 ymm0, ymm0, ymm0, 00000001b	;
	vmovss dword ptr [ RCX ], xmm0			;
	vpermilps ymm0, ymm0, 10010011b			;
	vmovss dword ptr [ RCX + 4 * 4 ], xmm0	;
	vperm2f128 ymm0, ymm0, ymm0, 00000001b	;
	vmovss dword ptr [ RCX + 4 * 5], xmm0	;
	vpermilps ymm0, ymm0, 10010011b			;
	vmovss dword ptr [ RCX + 4 * 3 ], xmm0	;
	vperm2f128 ymm0, ymm0, ymm0, 00000001b	;
	vmovss dword ptr [ RCX + 4 * 2], xmm0	;
	vpermilps ymm0, ymm0, 10010011b			;
	
	vmovss dword ptr [ RCX + 4 * (8 + 6) ], xmm1	;
	vperm2f128 ymm1, ymm1, ymm1, 00000001b			;
	vmovss dword ptr [ RCX + 4 * (8 + 7) ], xmm1	;
	vpermilps ymm1, ymm1, 10010011b					;
	vmovss dword ptr [ RCX + 4 * (8 + 1) ], xmm1	;
	vperm2f128 ymm1, ymm1, ymm1, 00000001b			;
	vmovss dword ptr [ RCX + 4 * 8 ], xmm0			;
	vpermilps ymm1, ymm1, 10010011b					;
	vmovss dword ptr [ RCX + 4 * (8 + 4) ], xmm1	;
	vperm2f128 ymm1, ymm1, ymm1, 00000001b			;
	vmovss dword ptr [ RCX + 4 * (8 + 5) ], xmm1	;
	vpermilps ymm1, ymm1, 10010011b					;
	vmovss dword ptr [ RCX + 4 * (8 + 3) ], xmm1	;
	vperm2f128 ymm1, ymm1, ymm1, 00000001b			;
	vmovss dword ptr [ RCX + 4 * (8 + 2) ], xmm1	;
	vpermilps ymm1, ymm1, 10010011b					;

	add RSP, 4 * 8 * 2 * 2;
	ret
FourierTransform ENDP

; -------------------------------------------------------------------------------------	;
; void CalculateSpectrum(spectrum_type* Spectrum, signal_type* Signal)					;
;	Ïðÿìîå ïðåîáðàçîâàíèå Ôóðüå. Âû÷èñëÿåò ñïåêòð Spectrum ïî ñèãíàëó Signal			;
;	FT_SIGNAL_SIZE = 8																	;
;	spectrum_type = float																;
;	signal_type = __int8																;
; -------------------------------------------------------------------------------------	;
CalculateSpectrum PROC	; [RCX] - Spectrum
						; [RDX] - Signal
	push RCX
	push RDX
	mov eax, 1	; Ïðîâåðêà ïîääåðæêè
	cpuid		;	AVX ïðîöåññîðîì
	bt ecx, 28
	jc AVX_SUPPORTED
	pop RDX
	pop RCX
	push R12		; Ñîõðàíåíèå non-volatile ðåãèñòðîâ
	push R13		;	â ñòåê ïåðåä íà÷àëîì ðàáîòû
	push R14		;	ïîäïðîãðàììû ñ öåëüþ
	push R15		;	èõ äàëüíåéøåãî âîññòàíîâëåíèÿ
	push RDI		;	ïåðåä âîçâðàùåíèåì
	push RSI		;	â âûçûâàþùóþ ôóíêöèþ

	mov R15, [RDX]	; Çàãðóçêà ñèãíàëà â ðåãèñòð R15

	xor R8, R8		; Îáíóëåíèå ðåãèñòðîâ
	xor R9, R9		;	äëÿ äàëüíåéøåé çàïèñè
	xor R10, R10	;	ýëåìåíòà ñèãíàëà
	xor R11, R11	;	x[i] â áàéòîâóþ ÷àñòü
	xor R12, R12	;	ðåãèñòðà R8+i
	xor R13, R13	;	ïîñðåäñòâîì ïåðåíîñà
	xor R14, R14	;	èç R15b

	mov R8b, R15b	; Ïåðåíîñ áàéòà x[0] èç R15
	shr r15, 8		;	ñ ïîñëåäóþùèì ñäâèãîì >> 8
	mov R12b, R15b	; Ïåðåíîñ áàéòà x[1] èç R15
	shr r15, 8		;	ñ ïîñëåäóþùèì ñäâèãîì >> 8
	mov R9b, R15b	; Ïåðåíîñ áàéòà x[2] èç R15
	shr r15, 8		;	ñ ïîñëåäóþùèì ñäâèãîì >> 8
	mov R13b, R15b	; Ïåðåíîñ áàéòà x[3] èç R15
	shr r15, 8		;	ñ ïîñëåäóþùèì ñäâèãîì >> 8
	mov R10b, R15b	; Ïåðåíîñ áàéòà x[4] èç R15
	shr r15, 8		;	ñ ïîñëåäóþùèì ñäâèãîì >> 8
	mov R14b, R15b	; Ïåðåíîñ áàéòà x[5] èç R15
	shr r15, 8		;	ñ ïîñëåäóþùèì ñäâèãîì >> 8
	mov R11b, R15b	; Ïåðåíîñ áàéòà x[6] èç R15
	shr r15, 8		;	ñ ïîñëåäóþùèì ñäâèãîì >> 8

		; Èíôîðìàöèÿ â ðåãèñòðàõ:
		;	R8-  x[0]
		;	R9-  x[2]
		;	R10- x[4]
		;	R11- x[6]
		;	R12- x[1]
		;	R13- x[3]
		;	R14- x[5]
		;	R15- x[7]
		
	sal r8, 7 * 8	; Â ðåçóëüòàòå
	sar r8, 7 * 8	;	ïåðåíîñà èç R15b
	sal r9, 7 * 8	;	â ðåãèñòðàõ çàïèñàíû
	sar r9, 7 * 8	;	çíà÷åíèÿ x[i].
	sal r10, 7 * 8	; Ñëåäóåò, îäíàêî æå,
	sar r10, 7 * 8	;	ó÷èòûâàòü òîò ôàêò, ÷òî
	sal r11, 7 * 8	;	÷òî ïåðåíîñ îñóùåñòâëÿëñÿ
	sar r11, 7 * 8	;	íå ñ ïîìîùüþ MOVSX,
	sal r12, 7 * 8	;	à çíà÷èò îñòàëüíûå áèòû
	sar r12, 7 * 8	;	â ñëó÷àå çàïèñè â ðåãèñòð
	sal r13, 7 * 8	;	îòðèöàòåëüíîãî ÷èñëà
	sar r13, 7 * 8	;	ñëåäóåò èíâåðòèðîâàòü.
	sal r14, 7 * 8	; Äëÿ ýòîãî èñïîëüçóåòñÿ
	sar r14, 7 * 8	;	ïîáèòîâûé ñäâèã âëåâî
	sal r15, 7 * 8	;	ñ ïîñëåäóþùèì çíàêîâûì
	sar r15, 7 * 8	;	ñäâèãîì âïðàâî

		; Îáðàáîòêà ÷¸òíûõ èíäåêñîâ

	mov RSI, R10	; Çàãðóçêà x[4] íà RSI
	add R10, R8		; Âû÷èñëåíèå e[0] è åãî çàïèñü íà R10
	sub R8, RSI		; Âû÷èñëåíèå e[1] è åãî çàïèñü íà R8
	mov RSI, R9		; Çàãðóçêà x[2] íà RSI
	add R9, R11		; Âû÷èñëåíèå o[0] è åãî çàïèñü íà R9
	sub R11, RSI	; Âû÷èñëåíèå ìíèìîé ÷àñòè o[1] è å¸ çàïèñü íà R11

		; Èíôîðìàöèÿ â ðåãèñòðàõ:
		;	R8-  Re(e[1])	Íå èìååò ìíèìîé ÷àñòè
		;	R9-  Re(o[0])	Íå èìååò ìíèìîé ÷àñòè
		;	R10- Re(e[0])	Íå èìååò ìíèìîé ÷àñòè
		;	R11- Im(o[1])	Íå èìååò äåéñòâèòåëüíîé ÷àñòè

		; E[0] = o[0] + e[0] => E[0] = Re(E[0])
		; E[2] = o[0] - e[0] => E[2] = Re(E[2])

	mov RSI, R9		; Çàãðóçêà o[0] íà RSI
	add r9, R10		; Âû÷èñëåíèå E[0] è åãî çàïèñü íà R9
	sub r10, RSI	; Âû÷èñëåíèå E[2] è åãî çàïèñü íà R10

		; E[1] = Re(e[1]) + Im(o[1])
		; E[3] = Re(e[1]) - Im(o[1])

		; Èíôîðìàöèÿ â ðåãèñòðàõ:
		;	R8-  Re(e[1])		Re(E[1]) è Re(E[3])
		;	R9-  Re(E[0])		Íå èìååò ìíèìîé ÷àñòè
		;	R10- Re(E[2])		Íå èìååò ìíèìîé ÷àñòè
		;	R11- Im(o[1])		Im(E[1]) è -Im(E[3])

		; Îáðàáîòêà íå÷¸òíûõ èíäåêñîâ

	mov RSI, R14		; Çàãðóçêà x[5] into RSI
	add R14, R12		; Âû÷èñëåíèå e[0] è åãî çàïèñü íà R14
	sub R12, RSI		; Âû÷èñëåíèå e[1] è åãî çàïèñü íà R12
	mov RSI, R13		; Çàãðóçêà x[3] into RSI
	add R13, R15		; Âû÷èñëåíèå o[0] è åãî çàïèñü íà R13
	sub R15, RSI		; Âû÷èñëåíèå ìíèìîé ÷àñòè o[1] è å¸ çàïèñü íà R15
	
		; Èíôîðìàöèÿ â ðåãèñòðàõ:
		;	R12- Re(e[1])	Íå èìååò ìíèìîé ÷àñòè
		;	R13- Re(o[0])	Íå èìååò ìíèìîé ÷àñòè
		;	R14- Re(e[0])	Íå èìååò ìíèìîé ÷àñòè
		;	R15- Im(o[1])	Íå èìååò äåéñòâèòåëüíîé ÷àñòè

		; O[0] = o[0] + e[0] => O[0] = Re(O[0])
		; O[2] = o[0] - e[0] => O[2] = Re(O[2])

	mov RSI, R13		; Çàãðóçêà o[0] íà RSI
	add R13, R14		; Âû÷èñëåíèå O[0] è åãî çàïèñü íà R13
	sub R14, RSI		; Âû÷èñëåíèå O[2] è åãî çàïèñü íà R14

		; O[1] = Re(e[1]) + Im(o[1])
		; O[3] = Re(e[1]) - Im(o[1])
		
	mov RDI, R11; RDI íå èìååò ïîñòôèêñà -b äëÿ çàïèñè â ìëàäøèé áàéò, à äëÿ âû÷èñëåíèé íóæåí ðåãèñòð R-b

		; Èíôîðìàöèÿ â ðåãèñòðàõ:
		;	R12-  Re(O[1]) = Re(O[3])
		;	R13-  Re(O[0])					Íå èìååò ìíèìîé ÷àñòè
		;	R14-  Re(O[2])					Íå èìååò ìíèìîé ÷àñòè
		;	R15-  Im(O[1]) = -Im(O[3])
		;	R8-   Re(E[1]) = Re(E[3])
		;	R9-   Re(E[0])					Íå èìååò ìíèìîé ÷àñòè
		;	R10-  Re(E[2])					Íå èìååò ìíèìîé ÷àñòè
		;	RDI-  Im(E[1]) = -Im(E[3])

	finit	; Èíèöèàëèçàöèÿ FPU

		; x[0] = Re(E[0]) + Re(O[0])
	mov R11, R9
	add R11, R13
	mov dword ptr [	RCX			], R11d		; spectrum[0] = x[0]
	fild dword ptr [RCX			]			; Êîíâåðòàöèÿ spectrum[0] int -> float
	fstp dword ptr [RCX			]			; Çàïèñü êîíâåðòèðîâàííîãî ÷èñëà â spectrum[0]
	mov dword ptr [	RCX + 8 * 4	], 0		; Im(x[0]) = 0

		; x[4] = Re(E[0]) - Re(O[0])
	mov R11, R9
	sub R11, R13
	mov dword ptr [ RCX + 4 * 4], R11d		; spectrum[4] = x[4]
	fild dword ptr [RCX + 4 * 4]			; Êîíâåðòàöèÿ spectrum[4] int -> float
	fstp dword ptr [RCX + 4 * 4]			; Çàïèñü êîíâåðòèðîâàííîãî ÷èñëà â spectrum[4]
	mov dword ptr [	RCX + (4 + 8) * 4], 0	; Im(x[4]) = 0
		
		; x[2] = Re(E[2]) - Im(O[2])
	mov dword ptr [	RCX +	 2 * 4		], R10d		; Re(spectrum[2]) = E[2]
	fild dword ptr [RCX +	 2 * 4		]			; Çàãðóçêà Re(spectrum[2]) íà FPU
	fstp dword ptr [RCX +	 2 * 4		]			; Çàïèñü êîíâåðòèðîâàííîãî âî float Re(spectrum[2])
	mov R11, 0
	sub R11, R14
	mov dword ptr [RCX +	(2 + 8) * 4	], R11d		; Im(spectrum[2]) = (-1) * O[2]
	fild dword ptr [RCX +	(2 + 8) * 4	]			; Çàãðóçêà Im(spectrum[2]) íà FPU
	fstp dword ptr [RCX +	(2 + 8) * 4	]			; Çàïèñü êîíâåðòèðîâàííîãî âî float Im(spectrum[2])
	
		; x[6] = Re(E[2]) + Im(O[2])
	mov dword ptr [RCX +	 6 * 4		], R10d		; Re(spectrum[6]) = E[2]
	fild dword ptr [RCX +	 6 * 4		]			; Çàãðóçêà Re(spectrum[6]) íà FPU
	fstp dword ptr [RCX +	 6 * 4		]			; Çàïèñü êîíâåðòèðîâàííîãî âî float Re(spectrum[6])
	mov dword ptr [RCX +	(6 + 8) * 4	], R14d		; Im(spectrum[6]) = O[2]
	fild dword ptr [RCX +	(6 + 8) * 4	]			; Çàãðóçêà Im(spectrum[2]) íà FPU
	fstp dword ptr [RCX +	(6 + 8) * 4	]			; Çàïèñü êîíâåðòèðîâàííîãî âî float Im(spectrum[2])

		; Çàãðóçêà sqrt(2) / 2 íà ST(0)
	mov dword ptr [RCX + 1 * 4], 2
	fild dword ptr [RCX + 1 * 4]
	fsqrt
	fild dword ptr [RCX + 1 * 4]
	fdivp
	
		; x[1] =
		;	Re(E[1]) [R8] + Im(E[1]) [RDI] +
		;	T(1-i) * (Re(e[1])[R12] + Im(o[1])[R15])
		;	[ R8 + TR12 + TR15 ; RDI + TR15 - TR12 ]
		; TRegister := (sqrt(2) / 2) * Register

		; Çàãðóçêà R8, R12, R15 è RDI â ñòåê FPU, óìíîæåíèå R12 è R15 íà (sqrt(2) / 2)
	mov dword ptr [RCX + 1 * 4], R8d
	mov R11, RDI
	mov dword ptr [RCX + 3 * 4], R11d
	mov dword ptr [RCX + 5 * 4], R12d
	mov dword ptr [RCX + 7 * 4], R15d

	fild dword ptr [RCX + 1 * 4]
	fild dword ptr [RCX + 3 * 4]
	fild dword ptr [RCX + 5 * 4]
	fmul ST(0), ST(3)
	fild dword ptr [RCX + 7 * 4]
	fmul ST(0), ST(4)
	fld ST(3)

		; Äàííûå â ñòåêå:
		;	ST(0)- Accumulator (R8)- âåðøèíà ñòåêà èñïîëüçóåòñÿ äëÿ âû÷èñëåíèÿ
		;	ST(1)- TR15
		;	ST(2)- TR12
		;	ST(3)- R11 (RDI)
		;	ST(4)- R8
		;	ST(5)- sqrt(2) / 2

		; x[1] =
		;	[ R8 + TR12 + TR15 ; RDI + TR15 - TR12 ]
		;	[ ST(4)+ST(2)+ST(1); ST(3)+ST(1)-ST(2)]
	fadd ST(0), ST(2)
	fadd ST(0), ST(1)
	fstp dword ptr [RCX + 1 * 4]

	fld ST(2)
	fadd ST(0), ST(1)
	fsub ST(0), ST(2)
	fstp dword ptr [RCX + (1 + 8) * 4]
		
		; x[5] =
		;	Re(E[1]) [R8] + Im(E[1]) [RDI] -
		;	T(1-i) * (Re(e[1])[R12] + Im(o[1])[R15])
		;	[ R8 - TR12 - TR15 ; RDI - TR15 + TR12 ]
		;	[ ST(4)-ST(2)-ST(1); ST(3)-ST(1)+ST(2)]
	fld ST(3)
	fsub ST(0), ST(2)
	fsub ST(0), ST(1)
	fstp dword ptr [RCX + 5 * 4]
	
	fld ST(2)
	fsub ST(0), ST(1)
	fadd ST(0), ST(2)
	fstp dword ptr [RCX + (5 + 8) * 4]
		
		; x[3] =
		;	Re(E[1]) [R8] + Im(E[1]) [RDI] +
		;	T(1+i) * (Re(e[1])[R12] + Im(o[1])[R15])
		;	[ R8 - TR12 - TR15 ; -RDI + TR15 - TR12 ]
		;	[ ST(4)-ST(2)-ST(1); -ST(3)+ST(1)-ST(2)]
	fld ST(3)
	fsub ST(0), ST(2)
	fsub ST(0), ST(1)
	fstp dword ptr [RCX + 3 * 4]
	
	fld ST(0)
	fsub ST(0), ST(2)
	fsub ST(0), ST(3)
	fstp dword ptr [RCX + (3 + 8) * 4]
		
		; x[7] =
		;	Re(E[1]) [R8] + Im(E[1]) [RDI] -
		;	T(1-i) * (Re(e[1])[R12] + Im(o[1])[R15])
		;	[ R8 + TR12 + TR15 ; -RDI - TR15 + TR12 ]
		;	[ ST(4)+ST(2)+ST(1); -ST(3)-ST(1)+ST(2)]
	fld ST(3)
	fadd ST(0), ST(2)
	fadd ST(0), ST(1)
	fstp dword ptr [RCX + 7 * 4]
	
	fld ST(1)
	fsub ST(0), ST(1)
	fsub ST(0), ST(3)
	fstp dword ptr [RCX + (7 + 8) * 4]

		; Âîññòàíîâëåíèå çíà÷åíèé non-volatile ðåãèñòðîâ

	pop RSI
	pop RDI
	pop R15
	pop R14
	pop R13
	pop R12

	ret
	AVX_SUPPORTED:

	pop RDX
	pop RCX

	sub RSP, 4 * 8 * 2 * 2;

	vzeroall;
	vmovups xmm1, dword ptr [RDX + 4]	; Ïîëó÷åíèå íóæíûõ
	vmovups xmm0, dword ptr [RDX]		;	äàííûõ èç ïàìÿòè
	vpmovsxbd xmm0, xmm0				;	è èõ çàïèñü â
	vpmovsxbd xmm1, xmm1				;	íåîáõîäèìîì äëÿ
	vcvtdq2ps xmm0, xmm0				;	êîððåêòíîé ðàáîòû
	vcvtdq2ps xmm1, xmm1				;	ôóíêöèè âèäå
	vpermilps ymm0, ymm0, 00011011b;
	vpermilps ymm1, ymm1, 00011011b;
		; ymm0 = [ 0 .. Re(x3..x0) ]
		; ymm1 = [ 0 .. Re(x7..x4) ]
		; ymm12 = [ 0 .. Im(x3..x0) ]
		; ymm14 = [ 0 .. Im(x7..x4) ]
	
	vmovups xmmword ptr [RSP], xmm0;
	vmovups xmmword ptr [RSP + 4 * 4], xmm1;
	vmovups ymm13, ymmword ptr [NormalMV];
	vmovups ymm15, ymmword ptr [NormalMV];
	
	push RCX;
	push RDX;
	mov RDX, RSP;
	call FourierTransform
	pop RDX;
	pop RCX;
	add RSP, 4 * 8 * 2 * 2;

	ret
CalculateSpectrum ENDP
; -------------------------------------------------------------------------------------	;
; void RecoverSignal(signal_type* Signal, spectrum_type* Spectrum)						;
;	Îáðàòíîå ïðåîáðàçîâàíèå Ôóðüå. Âû÷èñëÿåò ñèãíàë Signal ïî ñïåêòðó Spectrum			;
;	FT_SIGNAL_SIZE = 8																	;
;	spectrum_type = float																;
;	signal_type = __int8																;
; -------------------------------------------------------------------------------------	;
RecoverSignal PROC	; [RCX] - Signal
					; [RDX] - Spectrum

	sub RSP, 4 * 8 * 7; Âûäåëåíèå ìåñòà
	
	push RCX
	push RDX
	mov eax, 1	; Ïðîâåðêà ïîääåðæêè
	cpuid		;	AVX ïðîöåññîðîì
	bt ecx, 28
	jc AVX_SUPPORTED
	pop RDX
	pop RCX
	sub RSP, (8 * 2) * 8; Âûäåëåíèå ìåñòà äëÿ 8 êîìïëåêñíûõ ÷èñåë

	finit
	fld dword ptr [RDX				]	; Çàãðóçêà Re(x[0])
	fld dword ptr [RDX + 4 * 4		]	; Çàãðóçêà Re(x[4])
	fld ST(1)							; ST0 = Re(x[0])
	fadd ST(0), ST(1)					; Âû÷èñëåíèå Re(e[0]) = Re(x[0]) + Re(x[4])
	fld ST(2)							; ST0 = Re(x[0])
	fsub ST(0), ST(2)					; Âû÷èñëåíèå Re(e[1]) = Re(x[0]) - Re(x[4])
	fstp dword ptr [RSP + 1 * 4	]		; Çàïèñü Re(e[1])
	fstp dword ptr [RSP			]		; Çàïèñü Re(e[0])
	finit								; Èíèöèàëèçàöèÿ FPU (Ïðèìåíÿåòñÿ äëÿ îáíóëåíèÿ óêàçàòåëÿ ñòåêà)

		; Im(e[0]), Im(e[1]) îòáðàñûâàþòñÿ ïî ïðè÷èíå îòñóòñòâèÿ âëèÿíèÿ íà Re(X)

	fld dword ptr [RDX + 2 * 4		]	; Çàãðóçêà Re(x[2])
	fld dword ptr [RDX + 6 * 4		]	; Çàãðóçêà Re(x[6])
	fld ST(1)							; ST0 = Re(x[2])
	fadd ST(0), ST(1)					; Âû÷èñëåíèå Re(o[0]) = Re(x[2]) + Re(x[6])
		; Âû÷èñëåíèå Re(o[1]) = Re(x[2]) - Re(x[6])
		; o[1] * w(1, n) = o[1] * (-i)
		; Re(x[2]) - Re(x[6]) = -Im(o[1])
		; Im(o[1]) îòáðàñûâàåòñÿ ïî ïðè÷èíå îòñóòñòâèÿ âëèÿíèÿ íà Re(X)
	fstp dword ptr [RSP + 2 * 4 ]		; Çàïèñü Re(o[0])
	finit								; Èíèöèàëèçàöèÿ FPU (Ïðèìåíÿåòñÿ äëÿ îáíóëåíèÿ óêàçàòåëÿ ñòåêà)
	
	fld dword ptr [RDX + (2 + 8) * 4 ]	; Çàãðóçêà Im(x[2])
	fld dword ptr [RDX + (6 + 8) * 4 ]	; Çàãðóçêà Im(x[6])
	fld ST(0)							; ST0 = Im(x[6])
		; Âû÷èñëåíèå Im(o[1]) = Im(x[2]) - Im(x[6])
		; o[1] * w(1, n) = o[1] * (-i)
		; Im(x[2]) - Im(x[6]) = Re(o[1])
		; Reverse butterfly method -> Re(o[1]) = Im(x[6]) - Im(x[2])
	fsub ST(0), ST(2)
	fstp dword ptr [RSP + 3 * 4		  ]	; Çàïèñü Re(o[1])
	finit								; clearing ST

		; [RSP + x * 4] + [RSP + (x + 8) * 4]*i :
		;	x = 0 -> e[0]
		;	x = 1 -> e[1]
		;	x = 2 -> o[0]
		;	x = 3 -> o[1]

	fld dword ptr [RSP		 ]		; Çàãðóçêà Re(e[0])
	fld dword ptr [RSP + 2 * 4 ]	; Çàãðóçêà Re(o[0])
	fld ST(1)						; ST0 = Re(e[0])
	fadd ST(0), ST(1)				; Âû÷èñëåíèå Re(E[0])
	fld ST(2)						; ST0 = Re(e[0])
	fsub ST(0), ST(2)				; Âû÷èñëåíèå Re(E[2])
	fstp dword ptr [RSP + 2 * 4 ]	; Çàïèñü Re(E[2])
	fstp dword ptr [RSP			]	; Çàïèñü Re(E[0])
	finit
	
	fld dword ptr [RSP + 1 * 4 ]	; Çàãðóçêà Re(e[1])
	fld dword ptr [RSP + 3 * 4 ]	; Çàãðóçêà Re(o[1])
	fld ST(1)						; ST0 = Re(e[1])
	fadd ST(0), ST(1)				; Âû÷èñëåíèå Re(E[1])
	fld ST(2)						; ST0 = Re(e[1])
	fsub ST(0), ST(2)				; Âû÷èñëåíèå Re(E[3])
	fstp dword ptr [RSP + 3 * 4 ]	; Çàïèñü Re(E[3])
	fstp dword ptr [RSP + 1 * 4 ]	; Çàïèñü Re(E[1])
	finit

		; Im(E[0..3]) îòáðàñûâàþòñÿ ïî ïðè÷èíå îòñóòñòâèÿ âëèÿíèÿ íà Re(X)
	
		; processing odd indexes
	finit
	fld dword ptr [RDX + 1 * 4		]	; Çàãðóçêà Re(x[1])
	fld dword ptr [RDX + 5 * 4		]	; Çàãðóçêà Re(x[5])
	fld ST(1)							; ST0 = Re(x[1])
	fadd ST(0), ST(1)					; Âû÷èñëåíèå Re(e[0]) = Re(x[1]) + Re(x[5])
	fld ST(2)							; ST0 = Re(x[1])
	fsub ST(0), ST(2)					; Âû÷èñëåíèå Re(e[1]) = Re(x[1]) - Re(x[5])
	fstp dword ptr [RSP + 5 * 4	]		; Çàïèñü Re(e[1])
	fstp dword ptr [RSP + 4 * 4]		; Çàïèñü Re(e[0])
	finit								; clearing ST

	fld dword ptr [RDX + (1 + 8) * 4 ]	; Çàãðóçêà Im(x[1])
	fld dword ptr [RDX + (5 + 8) * 4 ]	; Çàãðóçêà Im(x[5])
	fld ST(1)							; ST0 = Im(x[1])
	fadd ST(0), ST(1)					; Âû÷èñëåíèå Im(e[0]) = Im(x[1]) + Im(x[5])
	fld ST(2)							; ST0 = Im(x[1])
	fsub ST(0), ST(2)					; Âû÷èñëåíèå Im(e[1]) = Im(x[1]) - Im(x[5])
	fstp dword ptr [RSP + (5 + 8) * 4 ] ; Çàïèñü Im(e[1])
	fstp dword ptr [RSP + (4 + 8) * 4 ]	; Çàïèñü Im(e[0])
	finit								; clearing ST

	fld dword ptr [RDX + 3 * 4		]	; Çàãðóçêà Re(x[3])
	fld dword ptr [RDX + 7 * 4		]	; Çàãðóçêà Re(x[7])
	fld ST(1)							; ST0 = Re(x[3])
	fadd ST(0), ST(1)					; Âû÷èñëåíèå Re(o[0]) = Re(x[3]) + Re(x[7])
	fld ST(2)							; ST0 = Re(x[7])
		; Âû÷èñëåíèå Re(o[1]) = Re(x[3]) - Re(x[7])
		; o[1] * w(1, n) = o[1] * (-i)
		; Re(x[3]) - Re(x[7]) = -Im(o[1]*w)
		; Reverse butterfly method -> Im(o[1]*w) = Im(x[3]) - Im(x[7])
	fsub ST(0), ST(2)
	fstp dword ptr [RSP + (7 + 8) * 4 ]	; Çàïèñü Im(o[1]*w)
	fstp dword ptr [RSP + 6 * 4 ]		; Çàïèñü Re(o[0]*w)
	finit								; clearing ST
	
	fld dword ptr [RDX + (3 + 8) * 4 ]	; Çàãðóçêà Im(x[3])
	fld dword ptr [RDX + (7 + 8) * 4 ]	; Çàãðóçêà Im(x[7])
	fld ST(1)							; ST0 = Im(x[3])
	fadd ST(0), ST(1)					; Âû÷èñëåíèå Im(o[0]) = Im(x[3]) + Im(x[7])
	fld ST(1)							; ST0 = Im(x[7])
		; Âû÷èñëåíèå Im(o[1]) = Im(x[3]) - Im(x[7])
		; o[1] * w(1, n) = o[1] * (-i)
		; Im(x[3]) - Im(x[7]) = Re(o[1]*w)
		; Reverse butterfly method -> Re(o[1]*w) = Im(x[7]) - Im(x[3])
	fsub ST(0), ST(3)
	fstp dword ptr [RSP + 7 * 4		  ]	; Çàïèñü Re(o[1]*w)
	fstp dword ptr [RSP + (6 + 8) * 4 ]	; Çàïèñü Im(o[0]*w)
	finit								; clearing ST

		; [RSP + x * 4] + [RSP + (x + 8) * 4]*i :
		;	x = 4 -> e[0]
		;	x = 5 -> e[1]
		;	x = 6 -> o[0]*w
		;	x = 7 -> o[1]*w

	fld dword ptr [RSP + 4 * 4 ]	; Çàãðóçêà Re(e[0])
	fld dword ptr [RSP + 6 * 4 ]	; Çàãðóçêà Re(o[0])
	fld ST(1)						; ST0 = Re(e[0])
	fadd ST(0), ST(1)				; Âû÷èñëåíèå Re(O[0])
	fstp dword ptr [RSP + 4 * 4 ]	; Çàïèñü Re(O[0])
	finit
	
	fld dword ptr [RSP + 5 * 4 ]	; Çàãðóçêà Re(e[1])
	fld dword ptr [RSP + 7 * 4 ]	; Çàãðóçêà Re(o[1])
	fld ST(1)						; ST0 = Re(e[1])
	fadd ST(0), ST(1)				; Âû÷èñëåíèå Re(O[1])
	fld ST(2)						; ST0 = Re(e[1])
	fsub ST(0), ST(2)				; Âû÷èñëåíèå Re(O[3])
	fstp dword ptr [RSP + 7 * 4 ]	; Çàïèñü Re(O[3])
	fstp dword ptr [RSP + 5 * 4 ]	; Çàïèñü Re(O[1])
	finit
		; Re(O[1]) and Re(O[3])
		; Im(O[2]) * (-i) = (e[0] - o[0]) * (-i) = Re(O[2]*w)
		; Îáðàòíàÿ áàáî÷êà èñïîëüçóåò êîìïëåêñíî-ñîïðÿæ¸ííûå w:
		;	Re(O[2]*w) = o[0] - e[0]
	fld dword ptr [RSP + (4 + 8) * 4 ]	; Çàãðóçêà Im(e[0])
	fld dword ptr [RSP + (6 + 8) * 4 ]	; Çàãðóçêà Im(o[0])
	fld ST(0)							; ST0 = Im(o[0])
	fsub ST(0), ST(2)					; Âû÷èñëåíèå Re(O[2])
	fstp dword ptr [RSP + 6 * 4 ]		; Çàïèñü Re(O[2])
	finit
	
	fld dword ptr [RSP + (5 + 8) * 4 ]	; Çàãðóçêà Im(e[1])
	fld dword ptr [RSP + (7 + 8) * 4 ]	; Çàãðóçêà Im(o[1])
	fld ST(1)							; ST0 = Im(e[1])
	fadd ST(0), ST(1)					; Âû÷èñëåíèå Im(O[1])
	fld ST(2)							; ST0 = Im(e[1])
	fsub ST(0), ST(2)					; Âû÷èñëåíèå Im(O[3])
	fstp dword ptr [RSP + (7 + 8) * 4 ]	; Çàïèñü Im(O[3])
	fstp dword ptr [RSP + (5 + 8) * 4 ]	; Çàïèñü Im(O[1])

		; Stack:
		; [RSP + x * 4] + [RSP + (x + 8) * 4] :
		;	[0..3] -> E[0..3]
		;	4 -> O[0]
		;	5 -> O[1] / W(1, 8)
		;	6 -> Re(O[2])
		;	7 -> O[3] / W(3, 8)

		; Çàïèñü sqrt(2) / 2 in ST(0)
	finit
	mov dword ptr [RCX + 1 * 4 ], 2
	fild dword ptr [RCX + 1 * 4]
	fsqrt
	fild dword ptr [RCX + 1 * 4]
	fdivp
	fld dword ptr [RSP + (5 + 8) * 4]	; Çàãðóçêà Im(O[1])
	fld dword ptr [RSP + 5 * 4]			; Çàãðóçêà Re(O[1])
		; multiplying O[1] by W(1, 8) is the same as Âû÷èñëåíèå
		;	Re(O[1]*w) = Im(O[1]) + Re(O[1])
		;	Im(O[1]*w) = Im(O[1]) - Re(O[1])- optimized out
		; Reverse butterfly method -> Re(O[1] * (1 + i)) = -Im(O[1]) + Re(O[1])
	fsub ST(0), ST(1)					; Âû÷èñëåíèå Re(O[1]*w)
	fmul ST(0), ST(2)
	fstp dword ptr [RSP + 5 * 4]		; Çàïèñü Re(O[1]*w)
	fstp ST(0)
	
	fld dword ptr [RSP + 7 * 4]			; Çàãðóçêà Re(O[3])
	fld dword ptr [RSP + (7 + 8) * 4]	; Çàãðóçêà Im(O[3])
		; Óìíîæåíèå O[3] íà W(3, 8) äà¸ò òîò æå ðåçóëüòàò, ÷òî è âû÷èñëåíèå
		;	Re(O[3]*w) = Im(O[3]) - Re(O[3])
		;	Im(O[3]*w) = Im(O[3]) + Re(O[3])- Îòáðàñûâàåòñÿ ïî ïðè÷èíå îòñóòñòâèÿ âëèÿíèÿ íà Re(X)
		; Îáðàòíàÿ áàáî÷êà èñïîëüçóåò êîìïëåêñíî-ñîïðÿæ¸ííûå w:
		;	Re(O[3] * (i - 1)) = -Im(O[1]) - Re(O[1])
	fldz
	fsub ST(0), ST(1)
	fsub ST(0), ST(2)					; Âû÷èñëåíèå Re(O[3]*w)
	fmul ST(0), ST(3)
	fstp dword ptr [RSP + 7 * 4]		; Çàïèñü Re(O[3]*w)
	
	finit
	fld1				; ST(0) = 1
	push 0				; M(0) = 8
	mov dword ptr [RSP], 8;
	fild dword ptr [RSP];
	fdivp ST(1), ST(0)	; ST(0) = 1 / 8

	fld dword ptr [RSP + 1 * 4 + 4]	; Çàãðóçêà E[0]
	fld dword ptr [RSP + 5 * 4 + 4]	; Çàãðóçêà O[0]
	fld ST(1)						; ST(0) = E[0]
	fadd ST(0), ST(1)				; X[0] = E[0] + O[0]
	fmul ST(0), ST(3)				; X[0] * (1 / N)
	fistp dword ptr [RSP]			; Çàïèñü Re(X[0])
	mov R8b, byte ptr [RSP]			;
	mov byte ptr [RCX], R8b			;
	fld ST(1)						; ST(0) = E[0]
	fsub ST(0), ST(1)				; X[4] = E[0] - O[0]
	fmul ST(0), ST(3)				; X[4] * (1 / N)
	fistp dword ptr [RSP]			; Çàïèñü Re(X[4])
	mov R8b, byte ptr [RSP]			;
	mov byte ptr [RCX + 4], R8b		;
	fstp ST(0)
	fstp ST(0)

	fld dword ptr [RSP + 2 * 4 + 4]	; Çàãðóçêà E[1]
	fld dword ptr [RSP + 6 * 4 + 4]	; Çàãðóçêà O[1]
	fld ST(1)						; ST(0) = E[1]
	fadd ST(0), ST(1)				; X[1] = E[1] + O[1]
	fmul ST(0), ST(3)				; X[1] * (1 / N)
	fistp dword ptr [RSP]			; Çàïèñü Re(X[1])
	mov R8b, byte ptr [RSP]			;
	mov byte ptr [RCX + 1], R8b		;
	fld ST(1)						; ST(0) = E[1]
	fsub ST(0), ST(1)				; X[5] = E[1] - O[1]
	fmul ST(0), ST(3)				; X[5] * (1 / N)
	fistp dword ptr [RSP]			; Çàïèñü Re(X[5])
	mov R8b, byte ptr [RSP]			;
	mov byte ptr [RCX + 5], R8b		;
	fstp ST(0)
	fstp ST(0)

	fld dword ptr [RSP + 3 * 4 + 4]	; Çàãðóçêà E[2]
	fld dword ptr [RSP + 7 * 4 + 4]	; Çàãðóçêà O[2]
	fld ST(1)						; ST(0) = E[2]
	fadd ST(0), ST(1)				; X[2] = E[2] + O[2]
	fmul ST(0), ST(3)				; X[2] * (1 / N)
	fistp dword ptr [RSP]			; Çàïèñü Re(X[2])
	mov R8b, byte ptr [RSP]			;
	mov byte ptr [RCX + 2], R8b		;
	fld ST(1)						; ST(0) = E[2]
	fsub ST(0), ST(1)				; X[6] = E[2] - O[2]
	fmul ST(0), ST(3)				; X[6] * (1 / N)
	fistp dword ptr [RSP]			; Çàïèñü Re(X[6])
	mov R8b, byte ptr [RSP]			;
	mov byte ptr [RCX + 6], R8b		;
	fstp ST(0)
	fstp ST(0)

	fld dword ptr [RSP + 4 * 4 + 4]	; Çàãðóçêà E[3]
	fld dword ptr [RSP + 8 * 4 + 4]	; Çàãðóçêà O[3]
	fld ST(1)						; ST(0) = E[3]
	fadd ST(0), ST(1)				; X[3] = E[3] + O[3]
	fmul ST(0), ST(3)				; X[3] * (1 / N)
	fistp dword ptr [RSP]			; Çàïèñü Re(X[3])
	mov R8b, byte ptr [RSP]			;
	mov byte ptr [RCX + 3], R8b		;
	fld ST(1)						; ST(0) = E[3]
	fsub ST(0), ST(1)				; X[7] = E[3] - O[3]
	fmul ST(0), ST(3)				; X[7] * (1 / N)
	fistp dword ptr [RSP]			; Çàïèñü Re(X[7])
	mov R8b, byte ptr [RSP]			;
	mov byte ptr [RCX + 7], R8b		;

	; fld ST(0)
	; fsub ST(0), ST(2)
	; fmul ST(0), ST(3)
	; fistp dword ptr [RCX + 4]
	; fstp ST(0)
	; fstp ST(0)
	; push 1

	add RSP, (8 * 2) * 8 + 8;
	ret

	AVX_SUPPORTED:
	pop RDX
	pop RCX
	vzeroall;
	vmovups xmm0, xmmword ptr [RDX]					; Ïîëó÷åíèå íóæíûõ
	vmovups xmm1, xmmword ptr [RDX + 4 * 4]			;	äàííûõ èç ïàìÿòè
	vmovups xmm12, xmmword ptr [RDX + 4 * 8]		;	è èõ çàïèñü
	vmovups xmm14, xmmword ptr [RDX + 4 * (8 + 4)]	;	â íåîáõîäèìîì
	vpermilps ymm0, ymm0, 00011011b					;	äëÿ êîððåêòíîé ðàáîòû
	vpermilps ymm1, ymm1, 00011011b					;	ôóíêöèè âèäå
	vpermilps ymm12, ymm12, 00011011b				;	â ðåãèñòðû
	vpermilps ymm14, ymm14, 00011011b				;	ymm(0, 1, 12, 14)

	push RCX
	push RDX
	mov RCX, RSP
	add RCX, 4 * 8 * 2
	vmovups ymm13, ymmword ptr [XImMV]	; Çàïèñü ñîîòâåòñòâóþùåãî
	vmovups ymm15, ymmword ptr [ImMV]	;	ìíîæèòåëÿ (Spectrum -> Signal)
	call FourierTransform				; Âûçîâ ôóíêöèè äëÿ âû÷èñëåíèÿ X[0-7]
	vmovups ymm0, [RCX]					; Çàïèñü ðåçóëüòàòà â ðåãèñòð ymm0
	pop RDX
	pop RCX

	vmovups ymm2, [const18] ; Äåëåíèå ðåçóëüòàòà íà 1/8
	vmulps ymm0, ymm0, ymm2
	vmulps ymm1, ymm1, ymm2
	vcvtps2dq ymm0, ymm0

	; vpmovdb xmm0, ymm0- AVX512
	; Çàïèñü ðåçóëüòàòà â âèäå ìàññèâà int8
	vmovups ymmword ptr [RSP], ymm0
	mov r8b, byte ptr [RSP]
	mov byte ptr [RCX], r8b;
	mov r8b, byte ptr [RSP + 4 * 1]
	mov byte ptr [RCX + 1], r8b;
	mov r8b, byte ptr [RSP + 4 * 2]
	mov byte ptr [RCX + 2], r8b;
	mov r8b, byte ptr [RSP + 4 * 3]
	mov byte ptr [RCX + 3], r8b;
	mov r8b, byte ptr [RSP + 4 * 4]
	mov byte ptr [RCX + 4], r8b;
	mov r8b, byte ptr [RSP + 4 * 5]
	mov byte ptr [RCX + 5], r8b;
	mov r8b, byte ptr [RSP + 4 * 6]
	mov byte ptr [RCX + 6], r8b;
	mov r8b, byte ptr [RSP + 4 * 7]
	mov byte ptr [RCX + 7], r8b;

	add RSP, 4 * 8 * 7

	ret
RecoverSignal ENDP
END