extern	printf

;constants.asm
extern	EOS
extern	NL
;core.asm
extern	min
extern	minu
extern	max
extern	maxu
extern	islower
extern	isupper
extern	tolower
extern	toupper
extern	itoa
extern	exit
;console.asm
extern	print
extern	puts
;string.asm
extern	strlen
extern	strcpy
extern	strlcpy
extern	strclr
extern	strlclr
extern	strcat
extern	strcmp
;file.asm
extern	fopen
extern	fclose
extern	fwrite

section	.rodata
	PRINT_nums	equ	1
	PRINT_strs	equ	1
	TEST_print	equ	1
	TEST_puts	equ	1
	TEST_printf	equ	1
	TEST_min	equ	1 ;includes minu
	TEST_max	equ	1 ;includes maxu
	TEST_strlen	equ	1
	TEST_islower	equ	1
	TEST_isupper	equ	1
	TEST_strcpy	equ	1
	TEST_strlcpy	equ	1
	TEST_strclr	equ	1
	TEST_strlclr	equ	1
	TEST_strcat	equ	1
	TEST_tolower	equ	1
	TEST_toupper	equ	1
	TEST_strcmp	equ	1
	TEST_file1	equ	1
	;TEST_itoa	equ	0 ; not included in these tests; printf() calls itoa for %d specifiers

	num1		dq	69
	num2		dq	0xFFFFFF
	num3		equ	25
	num4		dq	-90
	prntNums	db	"PRINT numbers:",NL,"> num1: %d",NL,"> num2: %d",NL,"> num3: %d",NL,"> num4: %d",NL,EOS

	str1		db	"Hello, world!",EOS
	str2		db	"Hello world!",EOS
	str3		db	"Howdy environment!",EOS
	str4		db	"Hell",EOS"o world!",EOS
	prntStrs	db	"PRINT strings:",NL,"> str1: %s",NL,"> str2: %s",NL,"> str3: %s",NL,"> str4: %s",NL,EOS

	; print()
	msgPrint	db	NL,"# print()",NL,EOS
	msgPrint1	db	"print() test",EOS
	; puts()
	msgPuts		db	NL,NL,"# puts()",NL,EOS
	msgPuts1	db	"puts() test",EOS
	; printf()
	testStr		db	"Testing: %s, %%, %s, %s, %f, %s, %d, %s, %s, %x, %s, %s, %d, %s",NL,EOS
	tS1		db	"one",EOS
	tS2		db	"two",EOS
	tS3		db	"three",EOS
	tS4		db	"four",EOS
	tS5		db	"five",EOS
	tS6		db	"six",EOS
	tS7		db	"seven",EOS
	tS8		db	"eight",EOS
	tS9		db	"noin",EOS
	msgPrintf	db	NL,"# printf()",EOS
	msgPrintf1	db	"TEST printf()",NL,EOS
	msgPrintf2	db	"TEST printf(testStr, tS1, tS2, tS3, invalid1, tS4, num4, tS5, tS6, invalid2, tS7, tS8, num1, tS9)",NL,EOS
	msgPrintf2b	db	"Return value: %d",NL,EOS
	; min() / minu()
	msgMin		db	NL,"# min() / minu()",EOS
	msgMin1		db	"TEST min(num1, num2): %d",NL,EOS
	msgMin2		db	"TEST minu(num1, num2): %d",NL,EOS
	msgMin3		db	"TEST min(num1, num3): %d",NL,EOS
	msgMin4		db	"TEST minu(num1, num3): %d",NL,EOS
	msgMin5		db	"TEST min(num1, num4): %d",NL,EOS
	msgMin6		db	"TEST minu(num1, num4): %d",NL,EOS
	msgMin7		db	"TEST min(num2, num4): %d",NL,EOS
	msgMin8		db	"TEST minu(num2, num4): %d",NL,EOS
	; max() / maxu()
	msgMax		db	NL,"# max() / maxu()",EOS
	msgMax1		db	"TEST max(num1, num2): %d",NL,EOS
	msgMax2		db	"TEST maxu(num1, num2): %d",NL,EOS
	msgMax3		db	"TEST max(num1, num3): %d",NL,EOS
	msgMax4		db	"TEST maxu(num1, num3): %d",NL,EOS
	msgMax5		db	"TEST max(num1, num4): %d",NL,EOS
	msgMax6		db	"TEST maxu(num1, num4): %d",NL,EOS
	msgMax7		db	"TEST max(num2, num4): %d",NL,EOS
	msgMax8		db	"TEST maxu(num2, num4): %d",NL,EOS
	; strlen()
	msgStrlen	db	NL,"# strlen()",EOS
	msgStrlen1	db	"TEST strlen(str1): %d",NL,EOS
	msgStrlen2	db	"TEST strlen(str2): %d",NL,EOS
	msgStrlen3	db	"TEST strlen(str3): %d",NL,EOS
	msgStrlen4	db	"TEST strlen(str4): %d",NL,EOS
	; islower()
	msgIslower	db	NL,"# islower()",EOS
	msgIslower1	db	"TEST islower(str1[0]): %d",NL,EOS ;str1[0] => 'H'
	msgIslower2	db	"TEST islower(str1[1]): %d",NL,EOS ;str1[1] => 'e'
	msgIslower3	db	"TEST islower(str1[5]): %d",NL,EOS ;str1[5] => ','
	; isupper()
	msgIsupper	db	NL,"# isupper()",EOS
	msgIsupper1	db	"TEST isupper(str1[0]): %d",NL,EOS ;str1[0] => 'H'
	msgIsupper2	db	"TEST isupper(str1[1]): %d",NL,EOS ;str1[1] => 'e'
	msgIsupper3	db	"TEST isupper(str1[5]): %d",NL,EOS ;str1[5] => ','
	; strcpy()
	msgStrcpy	db	NL,"# strcpy()",EOS
	msgStrcpy1	db	"TEST strcpy(strBuff1, str4): %s",NL,EOS
	msgStrcpy2	db	"TEST strcpy(strBuff1, str2): %s",NL,EOS
	msgStrcpy3	db	"TEST strcpy(strBuff1, str1): %s",NL,EOS
	; strlcpy()
	msgStrlcpy	db	NL,"# strlcpy()",EOS
	msgStrlcpy1	db	"TEST strlcpy(strBuff2, str1, -1) (%d): %s",NL,EOS
	msgStrlcpy2	db	"TEST strlcpy(strBuff2, str1, 0) (%d): %s",NL,EOS
	msgStrlcpy3	db	"TEST strlcpy(strBuff2, str1, 5) (%d): %s",NL,EOS
	msgStrlcpy4	db	"TEST strlcpy(strBuff2, str4, 8) (%d): %s",NL,EOS
	; strclr()
	msgStrclr	db	NL,"# strclr()",EOS
	msgStrclr1	db	"TEST strclr(strBuff1): (%d) %s",NL,EOS
	msgStrclr2	db	"> strcpy(strBuff1, str3). strBuff1 => %s",NL,EOS
	msgStrclr3	db	"TEST strclr(strBuff1): (%d) %s",NL,EOS
	; strlclr()
	msgStrlclr	db	NL,"# strlclr()",EOS
	msgStrlclr1	db	"TEST strlclr(strbuff1, 32): %s",NL,EOS
	msgStrlclr2	db	"> strcpy(strBuff1, str3). strBuff1 => %s",NL,EOS
	msgStrlclr3	db	"TEST strlclr(strBuff1, 32): %s",NL,EOS
	; strcat()
	msgStrcat	db	NL,"# strcat()",EOS
	msgStrcat1	db	"TEST strcat(strBuff1, str3): %s", NL,EOS
	msgStrcat2	db	"> strclr(strBuff1)",EOS
	msgStrcat3	db	"TEST strcat(strBuff1, str1): %s",NL,EOS
	msgStrcat4	db	"TEST strcat(strBuff1, str3): %s",NL,EOS
	; tolower()
	msgTolower	db	NL,"# tolower()",NL,"> strcpy(strBuff1, str3)",EOS
	msgTolower1	db	"TEST tolower(strBuff1[0]): %c",NL,EOS
	msgTolower2	db	"TEST tolower for whole strBuff1: %s",NL,EOS
	; toupper()
	msgToupper	db	NL,"# toupper()",NL,"> strcpy(strBuff1, str3)",EOS
	msgToupper1	db	"TEST toupper(strBuff1[0]): %c",NL,EOS
	msgToupper2	db	"TEST toupper for whole strBuff1: %s",NL,EOS
	; strcmp()
	msgStrcmp	db	NL,"# strcmp()",NL,"strlclr(strBuff1, 32)",NL,"strcpy(strBuff1, str1)",NL,"toupper(strBuff1[7])",EOS
	msgStrcmpStrs	db	"> str1: %s",NL,"> str2: %s",NL,"> str4: %s",NL,"> strBuff1: %s",NL,EOS
	msgStrcmp1	db	"TEST strcmp(strBuff1, str1): %d",NL,EOS
	msgStrcmp2	db	"TEST strcmp(str1, str2): %d",NL,EOS
	msgStrcmp3	db	"TEST strcmp(strBuff1, str2): %d",NL,EOS
	msgStrcmp4	db	"TEST strcmp(str4, str1): %d",NL,EOS
	msgStrcmp5	db	"TEST strcmp(str1, str4): %d",NL,EOS
	msgStrcmp6	db	"TEST strcmp(str1, str1): %d",NL,EOS
	; fopen(), fwrite(), fclose()
	testFile1	db	"testFile1.txt",EOS
	fileStr1	db	"Hello file world!",EOS
	msgFileB	db	NL,"# fopen(), fwrite(), fclose()",EOS
	msgFileB1	db	"TEST fopen('testFile1.txt', 'w'): %d",NL,EOS
	msgFileB2	db	"TEST fwrite(filePointer1, fileStr1): %d",NL,EOS
	msgFileB3	db	"TEST fclose(filePointer1): %d",NL,EOS
section .data
	filePointer1	dq	0
section .bss
	strBuff1	resb	32
	strBuff2	resb	8
section .text
	global _start
_start:
	push	rbp
	mov	rbp, rsp

%IF PRINT_nums
	xor	rax, rax
	lea	rdi, [rel prntNums]
	mov	rsi, [rel num1]
	mov	rdx, [rel num2]
	mov	rcx, num3
	mov	r8, [rel num4]
	call	printf
%ENDIF
%IF PRINT_strs
	xor	rax, rax
	lea	rdi, [rel prntStrs]
	lea	rsi, [rel str1]
	lea	rdx, [rel str2]
	lea	rcx, [rel str3]
	lea	r8, [rel str4]
	call	printf
%ENDIF

%IF TEST_print
	xor	rax, rax
	lea	rdi, [rel msgPrint]
	call	printf
	lea	rdi, [rel msgPrint1]
	call	print
%ENDIF
%IF TEST_puts
	xor	rax, rax
	lea	rdi, [rel msgPuts]
	call	printf
	lea	rdi, [rel msgPuts1]
	call	puts
%ENDIF
%IF TEST_printf
	lea	rdi, [rel msgPrintf]
	call	puts

	; TEST: printf(msgPrintf1)
	lea	rdi, [rel msgPrintf1]
	call	printf

	; TEST printf(testStr, tS1, tS2, tS3, invalid1, tS4, num4, tS5, tS6, invalid2, tS7, tS8, num1, tS9)
	lea	rdi, [rel msgPrintf2]
	call	printf

	lea	rdi, [rel testStr]
	lea	rsi, [rel tS1]
	lea	rdx, [rel tS2]
	lea	rcx, [rel tS3]
	mov	r8, 0
	lea	r9, [rel tS4]
	push	tS9
	push	qword [rel num1]
	push	tS8
	push	tS7
	push	0
	push	tS6
	push	tS5
	push	qword [num4]
	call	printf
	add	rsp, 8*8
	mov	rsi, rax
	lea	rdi, [msgPrintf2b]
	call	printf
%ENDIF
%IF TEST_min
	lea	rdi, [rel msgMin]
	call	puts

	;TEST: min(num1, num2)
	mov	rdi, [rel num1]
	mov	rsi, [rel num2]
	call	min
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMin1]
	call	printf
	;TEST: minu(num1, num2)
	mov	rdi, [rel num1]
	mov	rsi, [rel num2]
	call	minu
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMin2]
	call	printf
	;TEST: min(num1, num3)
	mov	rdi, [rel num1]
	mov	rsi, num3
	call	min
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMin3]
	call	printf
	;TEST: minu(num1, num3)
	mov	rdi, [rel num1]
	mov	rsi, num3
	call	minu
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMin4]
	call	printf
	;TEST: min(num1, num4)
	mov	rdi, [rel num1]
	mov	rsi, [rel num4]
	call	min
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMin5]
	call	printf
	;TEST: minu(num1, num4)
	mov	rdi, [rel num1]
	mov	rsi, [rel num4]
	call	minu
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMin6]
	call	printf
	;TEST: min(num2, num4)
	mov	rdi, [rel num2]
	mov	rsi, [rel num4]
	call	min
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMin7]
	call	printf
	;TEST: minu(num2, num4)
	mov	rdi, [rel num2]
	mov	rsi, [rel num4]
	call	minu
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMin8]
	call	printf
%ENDIF
%IF TEST_max
	lea	rdi, [rel msgMax]
	call	puts
	;TEST: max(num1, num2)
	mov	rdi, [rel num1]
	mov	rsi, [rel num2]
	call	max
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMax1]
	call	printf
	;TEST: maxu(num1, num2)
	mov	rdi, [rel num1]
	mov	rsi, [rel num2]
	call	maxu
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMax2]
	call	printf
	;TEST: max(num1, num3)
	mov	rdi, [rel num1]
	mov	rsi, num3
	call	max
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMax3]
	call	printf
	;TEST: maxu(num1, num3)
	mov	rdi, [rel num1]
	mov	rsi, num3
	call	maxu
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMax4]
	call	printf
	;TEST: max(num1, num4)
	mov	rdi, [rel num1]
	mov	rsi, [rel num4]
	call	max
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMax5]
	call	printf
	;TEST: maxu(num1, num4)
	mov	rdi, [rel num1]
	mov	rsi, [rel num4]
	call	maxu
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMax6]
	call	printf
	;TEST: max(num2, num4)
	mov	rdi, [rel num2]
	mov	rsi, [rel num4]
	call	max
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMax7]
	call	printf
	;TEST: maxu(num2, num4)
	mov	rdi, [rel num2]
	mov	rsi, [rel num4]
	call	maxu
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgMax8]
	call	printf
%ENDIF
%IF TEST_strlen
	lea	rdi, [rel msgStrlen]
	call	puts

	; TEST: strlen(str1)
	lea	rdi, [rel str1]
	call	strlen
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlen1]
	call	printf
	; TEST: strlen(str2)
	lea	rdi, [rel str2]
	call	strlen
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlen2]
	call	printf
	; TEST: strlen(str3)
	lea	rdi, [rel str3]
	call	strlen
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlen3]
	call	printf
	; TEST: strlen(str4)
	lea	rdi, [rel str4]
	call	strlen
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlen4]
	call	printf
%ENDIF
%IF TEST_islower
	lea	rdi, [rel msgIslower]
	call	puts

	; TEST: islower(str1[0])
	lea	rdi, [rel str1]
	call	islower
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgIslower1]
	call	printf
	; TEST: islower(str1[1])
	lea	rdi, [rel str1+1]
	call	islower
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgIslower2]
	call	printf
	; TEST: islower(str1[5])
	lea	rdi, [rel str1+5]
	call	islower
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgIslower3]
	call	printf
%ENDIF
%IF TEST_isupper
	lea	rdi, [rel msgIsupper]
	call	puts

	; TEST: isupper(str1[0])
	lea	rdi, [rel str1]
	call	isupper
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgIsupper1]
	call	printf
	; TEST: isupper(str1[1])
	lea	rdi, [rel str1+1]
	call	isupper
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgIsupper2]
	call	printf
	; TEST: isupper(str1[5])
	lea	rdi, [rel str1+5]
	call	isupper
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgIsupper3]
	call	printf
%ENDIF
%IF TEST_strcpy
	lea	rdi, [rel msgStrcpy]
	call	puts

	; TEST: strcpy(strBuff1, str4)
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str4]
	call	strcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcpy1]
	call	printf
	; TEST: strcpy(strBuff1, str2)
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str2]
	call	strcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcpy2]
	call	printf
	; TEST: strcpy(strBuff1, str1)
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str1]
	call	strcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcpy3]
	call	printf
%ENDIF
%IF TEST_strlcpy
	lea	rdi, [rel msgStrlcpy]
	call	puts

	; TEST: strlcpy(strBuff2, str1, -1)
	lea	rdi, [rel strBuff2]
	lea	rsi, [rel str1]
	mov	rdx, -1
	call	strlcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlcpy1]
	lea	rdx, [rel strBuff2]
	call	printf
	; TEST: strlcpy(strBuff2, str1, 0)
	lea	rdi, [rel strBuff2]
	lea	rsi, [rel str1]
	mov	rdx, 0
	call	strlcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlcpy2]
	lea	rdx, [rel strBuff2]
	call	printf
	; TEST: strlcpy(strBuff2, str1, 5)
	lea	rdi, [rel strBuff2]
	lea	rsi, [rel str1]
	mov	rdx, 5
	call	strlcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlcpy3]
	lea	rdx, [rel strBuff2]
	call	printf
	; TEST: strlcpy(strBuff2, str4, 8)
	lea	rdi, [rel strBuff2]
	lea	rsi, [rel str4]
	mov	rdx, 8
	call	strlcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlcpy4]
	lea	rdx, [rel strBuff2]
	call	printf
%ENDIF
%IF TEST_strclr
	lea	rdi, [rel msgStrclr]
	call	puts

	; TEST: strclr(strBuff1)
	lea	rdi, [rel strBuff1]
	call	strclr
	mov	rsi, rax
	xor	rax, rax
	lea	rdx, [rel strBuff1]
	lea	rdi, [rel msgStrclr1]
	call	printf
	; str3->strBuff1
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str3]
	call	strcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrclr2]
	call	printf
	; TEST: strclr(strBuff1)
	lea	rdi, [rel strBuff1]
	call	strclr
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrclr3]
	lea	rdx, [rel strBuff1]
	call	printf
%ENDIF
%IF TEST_strlclr
	lea	rdi, [rel msgStrlclr]
	call	puts

	; TEST: strlclr(strBuff1, 32)
	lea	rdi, [rel strBuff1]
	mov	rsi, 32
	call	strlclr
	xor	rax, rax
	lea	rdi, [rel msgStrlclr1]
	lea	rsi, [rel strBuff1]
	call	printf
	; str3->strBuff1
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str3]
	call	strcpy
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrlclr2]
	call	printf
	; TEST: strlclr(strBuff1, 32)
	lea	rdi, [rel strBuff1]
	mov	rsi, 32
	call	strlclr
	xor	rax, rax
	lea	rdi, [rel msgStrlclr3]
	lea	rsi, [rel strBuff1]
	call	printf
%ENDIF
%IF TEST_strcat
	lea	rdi, [rel msgStrcat]
	call	puts

	; TEST: strcat(strBuff1, str3)
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str3]
	call	strcat
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcat1]
	call	printf
	; CLEAR strBuff1
	lea	rdi, [rel msgStrcat2]
	call	puts
	lea	rdi, [rel strBuff1]
	call	strclr
	; TEST: strcat(strBuff1, str1)
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str1]
	call	strcat
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcat3]
	call	printf
	; TEST: strcat(strBuff1, str3)
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str3]
	call	strcat
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcat4]
	call	printf
%ENDIF
%IF TEST_tolower
	lea	rdi, [rel msgTolower]
	call	puts

	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str3]
	call	strcpy

	; TEST: tolower(strBuff1[0])
	lea	rdi, [rel strBuff1]
	call	tolower
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgTolower1]
	call	printf

	; TEST: tolower() whole strBuff1
	lea	rdi, [rel strBuff1]
	call	strlen
	mov	rcx, rax
	.tolowerLoop:
		movzx	r10, byte [rdi]
		mov	byte [rdi], r10b
		mov	r11, rcx
		call	tolower
		mov	rcx, r11
		mov	byte [rdi], al
		inc	rdi
		inc	r10
		loop	.tolowerLoop
	xor	rax, rax
	lea	rdi, [rel msgTolower2]
	lea	rsi, [rel strBuff1]
	call	printf
%ENDIF
%IF TEST_toupper
	lea	rdi, [rel msgToupper]
	call	puts

	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str3]
	call	strcpy

	; TEST: tolupper(strBuff1[0])
	lea	rdi, [rel strBuff1]
	call	toupper
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgToupper1]
	call	printf

	; TEST: toupper() whole strBuff1
	lea	rdi, [rel strBuff1]
	call	strlen
	mov	rcx, rax
	.toupperLoop:
		movzx	r10, byte [rdi]
		mov	byte [rdi], r10b
		mov	r11, rcx
		call	toupper
		mov	rcx, r11
		mov	byte [rdi], al
		inc	rdi
		inc	r10
		loop	.toupperLoop
	xor	rax, rax
	lea	rdi, [rel msgTolower2]
	lea	rsi, [rel strBuff1]
	call	printf
%ENDIF
%IF TEST_strcmp
	lea	rdi, [rel msgStrcmp]
	call	puts
	
	lea	rdi, [rel strBuff1]
	mov	rsi, 32
	call	strlclr
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str1]
	call	strcpy
	lea	rdi, [rel strBuff1+7]
	call	toupper
	mov	[strBuff1+7], al

	xor	rax, rax
	lea	rdi, [rel msgStrcmpStrs]
	lea	rsi, [rel str1]
	lea	rdx, [rel str2]
	lea	rcx, [rel str4]
	lea	r8, [rel strBuff1]
	call	printf

	; TEST: strcmp(strbuff1, str1)
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str1]
	call	strcmp
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcmp1]
	call	printf
	; TEST: strcmp(str1, str2)
	lea	rdi, [rel str1]
	lea	rsi, [rel str2]
	call	strcmp
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcmp2]
	call	printf
	; TEST: strcmp(strBuff1, str2)
	lea	rdi, [rel strBuff1]
	lea	rsi, [rel str2]
	call	strcmp
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcmp3]
	call	printf
	; TEST: strcmp(str4, str1)
	lea	rdi, [rel str4]
	lea	rsi, [rel str1]
	call	strcmp
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcmp4]
	call	printf
	; TEST: strcmp(str1, str4)
	lea	rdi, [rel str1]
	lea	rsi, [rel str4]
	call	strcmp
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcmp5]
	call	printf
	; TEST: strcmp(str1, str1)
	lea	rdi, [rel str1]
	mov	rsi, rdi
	call	strcmp
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgStrcmp6]
	call	printf
%ENDIF
%IF TEST_file1
	lea	rdi, [rel msgFileB]
	call	puts

	; TEST: fopen()
	lea	rdi, [rel testFile1]
	mov	rsi, 'w'
	call	fopen
	mov	r15, rax ;store filepointer to R15
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgFileB1]
	call	printf

	; TEST: fwrite()
	mov	rdi, r15
	lea	rsi, [fileStr1]
	call	fwrite
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgFileB2]
	call	printf

	; TEST: fclose()
	mov	rdi, r15
	call	fclose
	mov	rsi, rax
	xor	rax, rax
	lea	rdi, [rel msgFileB3]
	call	printf
%ENDIF

	leave
	mov	rdi, 0
	call	exit