Fizzbuzz.mas

        //    Yup! Fizzbuzz in Assembly!    //
        // COSC-2425 Computer Architecture  //
        //          Eliseo Duque            //
        //         April 12, 2024           //

        // ********** //
        // ** MAIN ** //
        // ********** //

MAIN, 	    Clear

/ Prepare to do  N mod(3)
            Load THREE
            Store DIVISOR
            Load N
            JnS MODULAR_DIV

/ Check if divisible
            Load REMAINDER
            Skipcond 800	/ Skip if (Remainder > 0)  "not divisible"
            JnS PRINT_FIZZ

/ Prepare to do  N mod(5)
            Load FIVE
            Store DIVISOR
            Load N
            JnS MODULAR_DIV

/ Check our result
            Load REMAINDER
            Skipcond 800	/ Skip if (Remainder > 0)  "not divisible"
            JnS PRINT_BUZZ

/ If no FIZZ or BUZZ, then print N

            Load DIVISIBLE_FLAG
            Skipcond 800
            JnS PRINT_N     / Skip if (Divisible_flag > 0)  "flag is set"

/ New Line
            Load \N
            Output

/ check if we need to iterate again
            Load N			/ Compare N to Max
            Subt N_MAX
            Skipcond 800	/ Skip if (N > Max_N)
            Jump CONTINUE
            HALT			/ Terminate the program

/ ++N
CONTINUE,	Load N
			Add ONE
            Store N

/ clear divisible flag
            Load ZERO
            Store DIVISIBLE_FLAG
            Jump MAIN	/ jump back to Main


        // ******************** //
        // * PRINT VALUE OF N * //
        // ******************** //

/ Output the value of N to OUTPUT: MODE UNICODE UTF-16BE
PRINT_N,    DEC 13
			Load N
			Store TEMP_N

/ if( n - 10 < 0 )
LOOP,		Load TEMP_N
			Subt TEN
            Skipcond 000
            Jump IF_2
/ print( n % 10 ) "aka" print ( n )
			Load TEMP_N
			Add UNICODE_OFFSET
			Output
            JumpI PRINT_N		/ return

/ if( n - 100 < 0 )
IF_2,		Load TEMP_N
			Subt ONE_HUNDRED
            Skipcond 000
            Jump IF_3
/ print( n / 10 )
            Load TEN
            Store DIVISOR
			Load TEMP_N
            JnS DIVISION
            Load QUOTIENT
            Add UNICODE_OFFSET
			Output

            Load NEG_ONE			/ reset quotient
            Store QUOTIENT
/ n %= 10 elimitate most significant digit
			Load TEN
            Store DIVISOR
            Load TEMP_N
            JnS MODULAR_DIV
			Load REMAINDER
            Store TEMP_N
            Jump LOOP

/ if( temp_n - 1,000 < 0 )
IF_3,		Load TEMP_N
			Subt ONE_THOUSAND
            Skipcond 000
            Jump IF_4
/ print( temp_n % 100 )
            Load ONE_HUNDRED
            Store DIVISOR
			Load TEMP_N
            JnS DIVISION
            Load QUOTIENT
			Add UNICODE_OFFSET
			Output

            Load NEG_ONE			/ reset quotient
            Store QUOTIENT
/ n %= 100 elimitate most significant digit
			Load ONE_HUNDRED
            Store DIVISOR
            Load TEMP_N
            JnS MODULAR_DIV
			Load REMAINDER
            Store TEMP_N
            Jump LOOP

/ if( temp_n - 10,000 < 0 )
IF_4,		Load TEMP_N
			Subt TEN_THOUSAND
            Skipcond 000
            Jump ELSE
/ print( temp_n % 1000 )
            Load ONE_THOUSAND
            Store DIVISOR
			Load TEMP_N
            JnS DIVISION
            Load QUOTIENT
            Add UNICODE_OFFSET
			Output

            Load NEG_ONE			/ reset quotient
            Store QUOTIENT
/ n %= 1000 elimitate most significant digit
			Load ONE_THOUSAND
            Store DIVISOR
            Load TEMP_N
            JnS MODULAR_DIV
			Load REMAINDER
            Store TEMP_N
            Jump LOOP

/* On computers with binary signed 2's compliment */
/* max integer cant exeed 32,767 (5 digits) */
/ print( temp_n / 10,000 )
ELSE,	    Load TEN_THOUSAND
            Store DIVISOR
			Load TEMP_N
            JnS DIVISION
            Load QUOTIENT
			Add UNICODE_OFFSET
			Output

            Load NEG_ONE			/ reset quotient
            Store QUOTIENT
/ n %= 10000 elimitate most significant digit
			Load TEN_THOUSAND
            Store DIVISOR
            Load TEMP_N
            JnS MODULAR_DIV
			Load REMAINDER
            Store TEMP_N
            Jump LOOP


        // ************** //
        // * PRINT CHAR * //
        // ************** //

PRINT_FIZZ,	DEC 14		/ return adress
			Load F
			Output
			Load I
        	Output
			Load Z
        	Output
			Output

			Load ONE    / set flag
            Store DIVISIBLE_FLAG
            JumpI PRINT_FIZZ


PRINT_BUZZ,	DEC 25		/ return adress
        	Load B
        	Output
			Load U
        	Output
			Load Z
        	Output
			Output

			Load ONE    / set flag
			Store DIVISIBLE_FLAG
        	JumpI PRINT_BUZZ

        // ************* //
        // * DIVISION  * //
        // ************* //

/ Division is implimented as repeated subtraction
/ untill ACCUMILATOR is negative
/ # QUOTIENT incrimented at each iteration
DIVISION,	DEC 0 				/ return adress stored here
LOOP_,		Store TEMP			/ store value of ACCUMILATOR
            Load QUOTIENT
            Add ONE				/ incriment QUOTIENT
            Store QUOTIENT

/ subtraction
            Load TEMP
            Subt DIVISOR

            Skipcond 000		/ return if TEMP < 0
            Jump LOOP_			/ repeat

			JumpI DIVISION		/ return

        // **************** //
        // * MODULAR DIV  * //
        // **************** //

/ Modular Division is implimented as repeated subtraction
/ untill ACCUMILATOR is negative
/ # REMAINDER is the value of AC before it dips below 0
MODULAR_DIV,DEC 0 				/ return adress stored here

LOOP__,		Store REMAINDER			/ store value of ACCUMILATOR
/ subtraction
            Subt DIVISOR

            Skipcond 000		/ return if ACCUMILATOR < 0
            Jump LOOP__			/ repeat

			JumpI MODULAR_DIV	/ return


        // *************  //
        // * Variables  * //
        // *************  //

/ Counter for the program
N,     DEC 1
N_MAX, DEC 99

/ Variables for printing N
UNICODE_OFFSET, DEC 48
DIVISIBLE_FLAG, DEC 0   / boolean value, used to see if we print N


/ Variables for division
QUOTIENT,	DEC -1
DIVISOR,	DEC 1
TEMP,		DEC 0	/ Store value of ACC temporarily (while incrimenting quotient)
TEMP_N,		DEC 0	/ Store value of ACC temporarily (while printing N)

/ Variables for mod division
REMAINDER,    DEC 0

/ ASCII VALUES
F, 	DEC 70 
I, 	DEC 73
Z, 	DEC 90
B, 	DEC 66
U, 	DEC 85
\N, DEC 10

/ Constants
TEN_THOUSAND, DEC 10000
ONE_THOUSAND, DEC 1000
ONE_HUNDRED,  DEC 100
TEN,          DEC 10
ONE,          DEC  1
ZERO,         DEC  0
NEG_ONE,	  DEC -1
THREE,	 DEC  3
FIVE,	 DEC  5