CSE 220: Systems Fundamentals I
Stony Brook University
Programming Project #2
Spring 2019
Assignment Due: Friday, March 15, 2019 by 11:59 pm
Learning Outcomes
After completion of this programming project you should be able to:
Read and write strings of arbitrary length.
Implement non-trivial algorithms that require conditional execution and iteration.
Design and code functions that implement the MIPS assembly register conventions.
Getting Started
Visit Piazza and download the file proj2.zip. Decompress the file and then open proj2.zip. Fill in the
following information at the top of proj2.asm:

1. your first and last name as they appear in Blackboard
2. your Net ID (e.g., jsmith)

3. your Stony Brook ID # (e.g., 111999999)
   Having this information at the top of the file helps us locate your work. If you forget to include this information
   but don’t remember until after the deadline has passed, don’t worry about it – we will track down your submission.
   Inside proj2.asm you will find several function stubs that consist simply of jr $ra instructions. Your job
   in this assignment is implement all the functions as specified below. Do not change the function names, as the
   grading scripts will be looking for functions of the given names. However, you may implement additional helper
   functions of your own, but they must be saved in proj2.asm. Helper functions will not be graded.
   If you are having difficulty implementing these functions, write out pseudocode or implement the functions in a
   higher-level language first. Once you understand the algorithm and what steps to perform, then translate the logic
   to MIPS assembly code.
   Be sure to initialize all of your values (e.g., registers) within your functions. Never assume registers or memory
   will hold any particular values (e.g., zero). MARS initializes all of the registers and bytes of main memory to
   zeroes. The grading scripts will fill the registers and/or main memory with random values before calling your
   functions.
   Finally, do not define a .data section in your proj2.asm file. A submission that contains a .data section
   will probably receive a score of zero.
   CSE 220 – Spring 2019 Programming Project #2 1
   Important Information about CSE 220 Homework Assignments
   Read the entire homework documents twice before starting. Questions posted on Piazza whose answers are
   clearly stated in the documents will be given lowest priority by the course staff.
   You must use the Stony Brook version of MARS posted on Piazza. Do not use the version of MARS
   posted on the official MARS website. The Stony Brook version has a reduced instruction set, added tools,
   and additional system calls you will need to complete the homework assignments.
   When writing assembly code, try to stay consistent with your formatting and to comment as much as
   possible. It is much easier for your TAs and the professor to help you if we can quickly figure out what your
   code does.
   You personally must implement homework assignments in MIPS Assembly language by yourself. You may
   not write or use a code generator or other tools that write any MIPS code for you. You must manually write
   all MIPS Assembly code you submit as part of the assignments.
   Do not copy or share code. Your submissions will be checked against other submissions from this semester
   and from previous semesters.
   Do not submit a file with the function/label main defined. You are also not permitted to start your label
   names with two underscores (). You will obtain a zero for an assignment if you do this.
   Submit your final .asm file to Blackboard by the due date and time. Late work will not be accepted or
   graded. Code that crashes and cannot be graded will earn no credit. No changes to your submission will be
   permitted once the deadline has passed.
   How Your CSE 220 Assignments Will Be Graded
   With minor exceptions, all aspects of your homework submissions will be graded entirely through automated
   means. Grading scripts will execute your code with input values (e.g., command-line arguments, function arguments)
   and will check for expected results (e.g., print-outs, return values, etc.) For this homework assignment you
   will be writing functions in assembly language. The functions will be tested independently of each other. This is
   very important to note, as you must take care that no function you write ever has side-effects or requires that other
   functions be called before the function in question is called. Both of these are generally considered bad practice
   in programming.
   Some other items you should be aware of:
   All test cases must execute in 100,000 instructions or fewer. Efficiency is an important aspect of programming.
   This maximum instruction count will be increased in cases where a complicated algorithm might be
   necessary, or a large data structure must be traversed. To find the instruction count of your code in Mars,
   go to the Tools menu and select Instruction Statistics. Press the button marked Connect to MIPS. Then
   assemble and run your code as normal.
   Any excess output from your program (debugging notes, etc.) might impact grading. Do not leave erroneous
   print-outs in your code.
   We will provide you with a small set of test cases for each assignment to give you a sense of how your work
   will be graded. It is your responsibility to test your code thoroughly by creating your own test cases.
   The testing framework we use for grading your work will not be released, but the test cases and expected
   results used for testing will be released.
   CSE 220 – Spring 2019 Programming Project #2 2
   Register Conventions
   You must follow the register conventions taught in lecture and reviewed in recitation. Failure to follow them will
   result in loss of credit when we grade your work. Here is a brief summary of the register conventions and how
   your use of them will impact grading:
   It is the callee’s responsibility to save any $s registers it overwrites by saving copies of those registers on
   the stack and restoring them before returning.
   If a function calls a secondary function, the caller must save $ra before calling the callee. In addition, if
   the caller wants a particular $a, $t or $v register’s value to be preserved across the secondary function
   call, the best practice would be to place a copy of that register in an $s register before making the function
   call.
   A function which allocates stack space by adjusting $sp must restore $sp to its original value before
   returning.
   Registers $fp and $gp are treated as preserved registers for the purposes of this course. If a function
   modifies one or both, the function must restore them before returning to the caller. There really is no reason
   for your code to touch the $gp register, so leave it alone.
   The following practices will result in loss of credit:
   “Brute-force”saving of all $s registers in a function or otherwise saving $s registers that are not overwritten
   by a function.
   Callee-saving of $a, $t or $v registers as a means of“helping”the caller.
   “Hiding”values in the $k, $f and $at registers or storing values in main memory by way of offsets to
   $gp. This is basically cheating or at best a form of laziness, so don’t do it. We will comment out any such
   code we find.
   How to Test Your Functions
   To test your implementated functions, open the provided main files in MARS. Next, assemble the main file and
   run it. MARS will include the contents of any .asm files referenced with the .include directive(s) at the end
   of the file and then add the contents of your proj2.asm file before assembling the program.
   Each main file calls a single function with one of the sample test cases and prints any return value(s). You will
   need to change the arguments passed to the functions to test your functions with the other cases. To test each
   of your functions thoroughly, create your own test cases in those main files. Your submission will not be graded
   using the examples provided in this document or using the provided main file(s).
   Again, any modifications to the main files will not be graded. You will submit only your proj2.asm for
   grading. Make sure that all code required for implementing your functions is included in the proj2.asm file.
   To make sure that your code is self-contained, try assembling your proj2.asm file by itself in MARS. If you
   get any errors (such as a missing label), this means that you need to refactor (reorganize) your code, possibly by
   moving labels you inadvertently defined in a main file (e.g., a helper function) to proj2.asm.
   CSE 220 – Spring 2019 Programming Project #2 3
   A Reminder on How Your Work Will be Graded
   It is imperative (crucial, essential, necessary, critically important) that you implement the functions below
   exactly as specified. Do not deviate from the specifications, even if you think you are implementing the
   program in a better way. Modify the contents of memory only as described in the function specifications!
   The Bacon Cipher
   In this assignment you will implementing a simple encryption scheme known as Bacon’s cipher. For each lowercase
   letter and for five other characters we assign a five-letter code as given in the below table:
   Character Encoding Character Encoding Character Encoding Character Encoding
   a AAAAA i ABAAA q BAAAA y BBAAA
   b AAAAB j ABAAB r BAAAB z BBAAB
   c AAABA k ABABA s BAABA space BBABA
   d AAABB l ABABB t BAABB ! BBABB
   e AABAA m ABBAA u BABAA’BBBAA
   f AABAB n ABBAB v BABAB , BBBAB
   g AABBA o ABBBA w BABBA . BBBBA
   h AABBB p ABBBB x BABBB eom BBBBB
   “BBBAA” is matched with a single quotation mark; “BBBAB” is matched with a comma. “BBBBB” is the code
   for“end-of-message”, which is explained below.
   Encryption
   Encryption requires a plaintext message, which may consist of any uppercase letters, lowercase letters and the
   five other characters given in the table. The first step of encryption is to change all letters in the plaintext message
   to lowercase. Then, each character of the modified plaintext is mapped to its five-letter code.
   For example, “I’m.a.Seawolf!!” is converted to “i’m.a.seawolf!!”. Then, each character is mapped
   to its five-letter code from the above table:
   ABAAA BBBAA ABBAA BBBBA AAAAA BBBBA BAABA AABAA AAAAA BABBA ABBBA ABABB
   i’m . a . s e a w o l
   AABAB BBABB BBABB BBBBB
   f ! ! eom
   We refer to this encoding as“A/B text”of the encoded plaintext throughout this document. The end-of-message
   marker, “BBBBB”, is appended to the end of the A/B text, which is needed during the decryption process. Note
   that the number of characters in the A/B text is exactly 5n + 5, where n is the length of the plaintext. Spaces
   between the five-letter codes are shown only for clarity and are not part of the actual A/B text.
   The encryption algorithm also requires a string of text that may contain any combination of any printable characters.
   This text will be manipulated to become the ciphertext. Each letter of the ciphertext will encode either an
   A or a B from the A/B text, while other non-letter characters carry no information. An A from the A/B text is
   encrypted in the ciphertext as a lowercase letter, whereas a B from the A/B text is encrypted in the ciphertext as
   CSE 220 – Spring 2019 Programming Project #2 4
   an uppercase letter. An example will help to clarify how this works.
   Suppose we wanted to encode the A/B given above in the text“Python features a dynamic type system and
   automatic memory management. It supports multiple PROGRAMMING paradigms.”On line 1 of each block
   below we see the ciphertext before the letter cases have been changed. On line 2 is the A/B text generated during
   the encoding process.
   Python features a dynamic type system and automatic memory management.
   ABAAAB BBAAABBA A BBBBAAA AAAB BBBABA ABA AABAAAAAA ABABBA ABBBAABABB
   It supports multiple PROGRAMMING paradigms.
   AA BABBBABB BBABBBBB BB
   Final ciphertext:
   pYthoN FEatuREs a DYNAmic typE SYStEm aNd auTomatic mEmORy mANAgeMeNT.
   it SuPPOrTS MUlTIPLE PROGRAMMING paradigms.
   Any letters from the ciphertext that follow the encoded end-of-message marker are left unmodified.
   Decryption
   Decryption is fundamentally the reverse process of encryption. Note that the original cases of the letters in the
   plaintext are lost during encryption. Therefore, the decryption process will generally not exactly reproduce the
   original plaintext message.
   Suppose we have the following ciphertext:
   Cse 220 AnD csE 320 FoRM A twO-CoURSe seQUeNce. 11001101 is a BInarY nUMBer.
   81FE2D is A bAsE-16 NUMBer. Base conversion is FUN!
   That ciphertext will be decoded into the following A/B text:
   BAABABAABBABBBAABBABBBAAABBABAAAAABBAAABABBBAABBBAABABABBBBB
   If we overlay the ciphertext with A/B text we will see why:
   Cse 220 AnD csE 320 FoRM A twO-CoURSe seQUeNce. 11001101 is a BInarY nUMBer.
   BAA BAB AAB BABB B AAB BABBBA AABBABAA AA A BBAAAB ABBBAA
   81FE2D is A bAsE-16 NUMBer.
   BB B AAB ABABBBB B
   The last few characters of the ciphertext don’t need to be decoded because they lie after the end-of-message
   marker, BBBBB.
   Now we take the A/B text and group it into five-letter groups that can be decoded:
   BAABA BAABB ABBBA ABBAB BBAAA BBABA AAAAB BAAAB ABBBA ABBBA ABABA BBBBB
   S T O N Y space B R O O K
   CSE 220 – Spring 2019 Programming Project #2 5
   The decrypted message is always generated in uppercase letters, regardless of the letter cases in the original
   plaintext message.
   Implementation
   Before implementing the encryption and decryption algorithms we will need to write a few functions for working
   with strings.
   Part I: Convert a String to Lowercase
   int to_lowercase(string str)
   This function takes a null-terminated string (possibly empty) and changes all of its uppercase letters to lowercase.
   All other characters in the string remain unchanged.
   The function takes the following arguments, in this order:
   str: The starting address of a null-terminated string.
   Returns in $v0:
   The number of letters changed from uppercase to lowercase.
   Additional requirements:
   The function must not write any changes to main memory except as specified.
   Examples:
   Function Argument Return Value Updated str
   “Wolfie Seawolf!!! 2019??” 2 “wolfie seawolf!!! 2019??”
   “” 0 “”
   “programming” 0 “programming”
   Part II: Compute a String’s Length
   int strlen(string str)
   This function takes a null-terminated string (possibly empty) and returns its length (i.e., the number of characters
   in the string).
   The function takes the following arguments, in this order:
   str: The starting address of a null-terminated string
   Returns in $v0:
   The length of the string, not including the null-terminator.
   Additional requirements:
   CSE 220 – Spring 2019 Programming Project #2 6
   ? The function must not write any changes to main memory.
   Examples:
   Function Arguments Return Value
   “Wolfie Seawolf!!! 2019??” 24
   “MIPS” 4
   “” 0
   Part III: Count the Number of Letters in a String
   int count_letters(string str)
   This function takes a null-terminated string (possibly empty) and returns the number of letters in the string.
   The function takes the following arguments, in this order:
   str: The starting address of a null-terminated string
   Returns in $v0:
   The number of letters in the string.
   Additional requirements:
   The function must not write any changes to main memory.
   Examples:
   Function Arguments Return Value
   “Wolfie Seawolf!!! 2019??” 13
   “220” 0
   “” 0
   Part IV: Encode Plaintext in“A/B”Format
   (int, int) encode_plaintext(string plaintext, char[] ab_text,
   int ab_text_length, char[] codes)
   This function takes the null-terminated string plaintext (possibly empty) consisting of lowercase letters,
   spaces and punctuation marks, and encodes each lowercase letter as its 5-letter uppercase Bacon code in ab text.
   After the last letter of plaintext has been encoded and stored in ab text, the function writes the string
   “BBBBB” into ab text immediately after after the last encoded letter. “BBBBB” is called the“end-of-message
   marker.”Because ab text might not be long enough to accommodate the fully-encoded plaintext, the function
   encodes as many characters of the plaintext as possible, following them with the end-of-message code
   (“BBBBB”). The function does not null-terminate ab text. In some cases, ab text might not even be large
   enough to store the end-of-message marker. See the examples below.
   CSE 220 – Spring 2019 Programming Project #2 7
   The function takes the following arguments, in this order:
   plaintext: The starting address of the null-terminated string to encode.
   ab text: The starting address of a memory buffer set aside to store the encoded plaintext.
   ab text length: The number of bytes in ab text.
   codes: The starting address of the array described below.
   The codes array will always have the following contents. This array is provided merely as a convenience to
   several of the functions for the assignment. Your functions are not required to use it.

   The codes for lowercase letters a through z are followed by codes

   for other characters.

   .ascii “AAAAA” # a
   .ascii “AAAAB” # b
   .ascii “AAABA” # c

   … etc. …

   .ascii “BBAAA” # y
   .ascii “BBAAB” # z
   .ascii “BBABA” # space
   .ascii “BBABB” # exclamation mark
   .ascii “BBBAA” # quotation mark
   .ascii “BBBAB” # comma
   .ascii “BBBBA” # period
   .ascii “BBBBB” # end-of-message marker
   Returns in $v0:
   The number of lowercase letters from plaintext that were encoded as 5-letter codes in ab text. This
   count does not include the end-of-message marker.
   Returns in $v1:
   1 if the entire plaintext was sucessfully encoded in ab text; 0 if not all of the plaintext could be encoded
   in ab text.
   Additional requirements:
   The function must not write any changes to main memory except as specified.
   encode plaintext must call strlen.
   Examples:
   The examples given below do not cover every possible edge case your function might encounter. Think carefully
   about special cases and, if it is not clear to you how the function should handle a special case, post a question on
   Piazza.
   Case #1: plaintext is non-empty and ab text is large enough to encode the entire plaintext message,
   including the end-of-message marker. The function completely encodes the plaintext and returns N, 1, where N
   CSE 220 – Spring 2019 Programming Project #2 8
   is the number of characters in plaintext.
   Function arguments:
   plaintext = “java! not. a. fan.”
   ab_text = “
   “
   ab_text_length = 98
   Return values: 18, 1
   Updated ab text: “ABAABAAAAABABABAAAAABBABBBBABAABBABABBBABAABBBBBBABBABAAAAAA
   BBBBABBABAAABABAAAAAABBABBBBBABBBBB*“
   Case #2: plaintext is non-empty and ab text is not large enough to encode the entire plaintext message, but
   can accommodate at least one plaintext character’s code, plus the end-of-message marker. The function encodes
   as much of the plaintext as possible, writes the end-of-message marker, and returns N, 0, where N is the number
   of characters in plaintext that were successfully encoded.
   Function arguments:
   plaintext = “we love mips…”
   ab_text =
   ab_text_length = 63
   Return values: 11, 0
   Updated ab text: “BABBAAABAABBABAABABBABBBABABABAABAABBABAABBAAABAAAABBBBBB
   BBB”
   Case #3: plaintext is non-empty and ab text is not large enough to encode even a single character from
   the plaintext, but it does have enough room to store the end-of-message marker. The function writes only the
   end-of-message marker into ab text and returns 0, 0.
   Function arguments:
   plaintext = “we love mips…”
   ab_text = “*”
   ab_text_length = 9
   Return values: 0, 0
   Updated ab text: “BBBBB**”
   Case #4: plaintext is non-empty and ab text is not large enough to encode even the end-of-message
   marker. The function writes no changes to ab text and returns 0, 0.
   CSE 220 – Spring 2019 Programming Project #2 9
   Function arguments:
   plaintext = “we love mips…”
   ab_text = “@@@”
   ab_text_length = 3
   Return values: 0, 0
   Updated ab text: “@@@”
   Case #5: plaintext is empty and ab text is large enough to encode the end-of-message marker. The
   function writes the end-of-message marker to ab text and returns 0, 1.
   Function arguments:
   plaintext = “”
   ab_text = “!!!!!!!!!!!!!!!!”
   ab_text_length = 16
   Return values: 0, 1
   Updated ab text: “BBBBB!!!!!!!!!!!”
   Case #6: plaintext is empty and ab text is not large enough to encode the end-of-message marker. The
   function writes no changes to ab text and returns 0, 0.
   Function arguments:
   plaintext = “”
   ab_text = “gg!”
   ab_text_length = 2
   Return values: 0, 0
   Updated ab text: “ggg”
   Part V: Encrypt a Message
   (int, int) encrypt(string plaintext, string ciphertext, char[] ab_text,
   int ab_text_length, char[] codes)
   This function takes the null-terminated string plaintext (possibly empty) consisting of lowercase letters,
   spaces and punctuation marks, and encrypts the plaintext using Bacon’s cipher as explained earlier in the assignment,
   storing the result in ciphertext.
   The function takes the following arguments, in this order:
   CSE 220 – Spring 2019 Programming Project #2 10
   ? plaintext: The starting address of the null-terminated string to encrypt.
   ciphertext: The starting address of the null-terminated string that will be modified to store the encrypted
   plaintext. The function may change the case of only those letters that must be changed to represent A/B
   letters taken from the ab text. No other characters may be changed. For example, once “BBBBB” has
   been represented as five sequential uppercase letters in the ciphertext string, no characters after those five
   letters from the ciphertext may be modified. See the examples below for further explanation.
   ab text: The starting address of a memory buffer created to store the encoded plaintext. You may not
   assume that ab text is long enough to encode the entire plaintext. In such cases, only a portion of the
   plaintext will be encrypted.
   ab text length: The number of bytes in ab text.
   codes: The starting address of the array of Bacon cipher codes described earlier in the assignment.
   Returns in $v0:
   The number of letters of ciphertext that actually encode A/B code letters. See the examples below for
   further explanation.
   Returns in $v1:
   1 if the entire plaintext was successfully encrypted in ciphertext; 0 if not all of the plaintext could be
   encrypted because ab text is too short.
   Additional requirements:
   The function must not write any changes to main memory except as specified. As an example, this function
   must not write any changes to ab text; only encode plaintext may write such changes.
   encrypt must call to lowercase, count letters and encode plaintext.
   Examples:
   The examples given below do not cover every possible edge case your function might encounter. Think carefully
   about special cases and, if it is not clear to you how the function should handle a special case, post a question on
   Piazza.
   Case #1: plaintext is non-empty and ab text is large enough to encode the entire plaintext message,
   including the end-of-message marker. The function completely encrypts the plaintext and returns 5*(N+1), 1,
   where N is the number of characters in plaintext.
   Function arguments:
   plaintext = “Stony Brook”
   ciphertext = “CSE 220 and CSE 320 form a two-course sequence. 11001101 is a
   binary number. 81FE2D is a base-16 number. Base conversion is
   FUN!”
   ab_text = “*
   **”
   ab_text_length = 67
   CSE 220 – Spring 2019 Programming Project #2 11
   Return values: 60, 1
   Updated plaintext: “stony brook”
   Updated ciphertext: “Cse 220 AnD csE 320 FoRM A twO-CoURSe seQUeNce. 11001101
   is a BInarY nUMBer. 81FE2D is A bAsE-16 NUMBer. Base conversion is FUN!”
   Note that the substring “E-16 NUMB” encodes end-of-message marker, “BBBBB” and that the remainder of the
   initial ciphertext remains unchanged: “er. Base conversion is FUN!”.
   Case #2: plaintext is non-empty and ab text is not large enough to encode the entire plaintext message,
   but can accommodate at least one plaintext character’s code, plus the end-of-message marker. The function
   encrypts as much of the plaintext as possible and returns 5*(N+1), 0, where N is the number of characters in
   plaintext that were successfully encrypted.
   Function arguments:
   plaintext = “I’m.a.Seawolf!!”
   ciphertext = “Python features a dynamic type system and automatic memory
   management. It supports multiple PROGRAMMING paradigms.”
   ab_text = “&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
   &&&&&&&&&&&”
   ab_text_length = 72
   Return values: 70, 0
   Updated plaintext: “i’m.a.seawolf!!”
   Updated ciphertext: “pYthoN FEatuREs a DYNAmic typE SYStEm aNd auTomatic mEmORy
   mANAgeMeNT. it SuPPORTS multiple PROGRAMMING paradigms.”
   Case #3: plaintext is non-empty and ab text is not large enough to encode even a single character from
   the plaintext, but it does have enough room to store the end-of-message marker. The function encrypts only the
   end-of-message marker and returns 5, 0.
   Function arguments:
   plaintext = “Wolfie Seawolf”
   ciphertext = “Python features a dynamic type system and automatic memory
   management. It supports multiple programming paradigms.”
   ab_text = ““
   ab_text_length = 6
   Return values: 5, 0
   Updated plaintext: “wolfie seawolf”
   Updated ciphertext: “PYTHOn features a dynamic type system and automatic memory
   CSE 220 – Spring 2019 Programming Project #2 12
   management. It supports multiple programming paradigms.”
   Case #4: plaintext is non-empty and ab text is not large enough to encode even the end-of-message
   marker. The function writes no changes to ab text or ciphertext and returns 0, 0.
   Function arguments:
   plaintext = “Wolfie Seawolf”
   ciphertext = “Python features a dynamic type system and automatic memory
   management. It supports multiple programming paradigms.”
   ab_text = “%%”
   ab_text_length = 2
   Return values: 0, 0
   Updated plaintext: “Wolfie Seawolf”
   Updated ciphertext: “Python features a dynamic type system and automatic memory
   management. It supports multiple programming paradigms.”
   Case #5: plaintext is empty and ab text is large enough to encode the end-of-message marker. The
   function call to encode plaintext writes the end-of-message marker to ab text and then encrypt returns
   5, 1.
   Function arguments:
   plaintext = “”
   ciphertext = “The Scholars program is a vibrant community of high-achieving
   students at Stony Brook.”
   ab_text = “!!!!!!!!!!!!!!!!”
   ab_text_length = 16
   Return values: 5, 1
   Updated plaintext: “”
   Updated ciphertext: “THE SCholars program is a vibrant community of high-achieving
   students at Stony Brook.”
   Case #6: plaintext is empty and ab text is not large enough to encode the end-of-message marker. No
   changes are written ab text or plaintext. The function returns 0, 0.
   Function arguments:
   plaintext = “”
   ciphertext = “The Scholars program is a vibrant community of high-achieving
   students at Stony Brook.”
   CSE 220 – Spring 2019 Programming Project #2 13
   ab_text = “!!!!”
   ab_text_length = 4
   Return values: 0, 0
   Updated plaintext: “”
   Updated ciphertext: “The Scholars program is a vibrant community of high-achieving
   students at Stony Brook.”
   Part VI: Decode Ciphertext into an“A/B”String
   int decode_ciphertext(string ciphertext, char[] ab_text, int ab_text_length,
   char[] codes)
   This function takes a string of ciphertext and decodes it into a string of A and B characters. In sequential manner,
   starting at the leftmost character of ciphertext, each lowercase letter is encoded as an A character in ab text,
   and each uppercase letter is encoded as a B character in ab text. Non-letter characters in ciphertext are
   simply ignored. You may assume that the end-of-message marker is encoded somewhere in the ciphertext. The
   function does not null-terminate the ab text string.
   If the number of letters in ciphertext is greater than the length of ab text, the function returns -1 and
   makes no changes to memory.
   The function takes the following arguments, in this order:
   ciphertext: The starting address of the null-terminated ciphertext string to decode as explained above.
   ab text: The starting address of a memory buffer created to store the decoded ciphertext.
   ab text length: The size of the ab text in bytes.
   codes: The starting address of the array of Bacon cipher codes described earlier in the assignment.
   Returns in $v0:
   The number of characters written to ab text by the function, or -1 on error as described above.
   Additional requirements:
   The function must not write any changes to main memory except as specified.
   decode ciphertext must call strlen and count letters.
   Examples:
   The examples given below do not cover every possible edge case your function might encounter. Think carefully
   about special cases and, if it is not clear to you how the function should handle a special case, post a question on
   Piazza.
   Case #1: ab text is exactly the right length to store the decoded ciphertext.
   CSE 220 – Spring 2019 Programming Project #2 14
   Function arguments:
   ciphertext = “AbcDefgHijkLMnOpqrSTUVwXyzaBCDefGhijKlMNoPQRSTUvWXYZABC”
   ab_text = “///////////////////////////////////////////////////////”
   ab_text_length = 55
   Return value: 55
   Updated ab text: “BAABAAABAAABBABAAABBBBABAAABBBAABAAABABBABBBBBBABBBBBBB”
   Case #2: ab text has bytes leftover after storing the decoded ciphertext
   Function arguments:
   ciphertext = “sHARDPLate Is aN AncIENt AND maGIcAL TyPe OF fUlL-BODy ARMOr
   FOUNd ON ROsHAr. It iS infUseD wITh StoRMLigHt AnD GRANts
   great power.”
   ab_text = “*
   *“
   ab_text_length = 114
   Return value: 95
   Updated ab text: “ABBBBBBAAABAABBAABBBABBBAABBABBBABABBABABBBBABBBBABBBBABBBBAB
   BABAABAAABAABABBABAABBBAABABABBBBB*“
   Case #3: ciphertext contains only the end-of-message marker.
   Function arguments:
   ciphertext = “2019 GO STONY BROOK!”
   ab_text = “+++++++++++++++”
   ab_text_length = 15
   Return value: 5
   Updated ab text: “BBBBB++++++++++”
   Part VII: Decrypt a Message
   int decrypt(string ciphertext, string plaintext, char[] ab_text,
   int ab_text_length, char[] codes)
   This function takes a ciphertext string as its first argument, calls decode ciphertext to transform the ciphertext
   into an A/B string, and then finally decrypts the A/B string, storing the decrypted plaintext in the given
   plaintext buffer. The function null-terminates the plaintext before returning.
   CSE 220 – Spring 2019 Programming Project #2 15
   If the call to decode ciphertext returns -1, decrypt returns -1 and makes no changes to memory.
   The function takes the following arguments, in this order:
   ciphertext: The starting address of the null-terminated ciphertext string to decrypt.
   plaintext: The starting address of a memory buffer to store the plaintext. The buffer is guaranteed to be
   large enough to store the decrypted message and a null-terminator.
   ab text: The starting address of a memory buffer created to store the decoded ciphertext.
   ab text length: The size of the ab text in bytes.
   codes: The starting address of the array of Bacon cipher codes described earlier in the assignment. Note
   that this argument will be passed to decrypt on the stack at memory address 0($sp).
   Returns in $v0:
   The number of characters in the decrypted message, not including the null-terminator written by the function,
   or -1 on error as described above.
   Additional requirements:
   The function must not write any changes to main memory except as specified. As an example, this function
   must not write any changes to ab text; only decode ciphertext may write such changes.
   decrypt must call decode ciphertext.
   Examples:
   The examples given below do not cover every possible edge case your function might encounter. Think carefully
   about special cases and, if it is not clear to you how the function should handle a special case, post a question on
   Piazza.
   Case #1: General case. The ciphertext contains at least one printable character.
   Function arguments:
   ciphertext = “Cse 220 AnD csE 320 FoRM A twO-CoURSe seQUeNce. 11001101 is a
   BInarY nUMBer. 81FE2D is A bAsE-16 NUMBer. Base conversion is
   FUN!”
   plaintext = “@@@@@@@@@@@@@@@@@@@@@@@@@”
   ab_text = “%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   %%%%%%”
   ab_text_length = 81
   Return value: 11
   Updated plaintext: STONY BROOK\0@@@@@@@@@@@@@
   Updated ab text: BAABABAABBABBBAABBABBBAAABBABAAAAABBAAABABBBAABBBAABABABBBBB%%
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   CSE 220 – Spring 2019 Programming Project #2 16
   Case #2: ciphertext contains only the end-of-message marker.
   Function arguments:
   ciphertext = “2019 GO STONY BROOK!”
   plaintext = “&&&&&&&&&&&&&&”
   ab_text = “++++++++++++++++”
   ab_text_length = 16
   Return value: 0
   Updated plaintext: \0&&&&&&&&&&&&
   Updated ab text: “BBBBB+++++++++++”
   Case #3: ciphertext contains more letters than can be decoded into ab text
   Function arguments:
   ciphertext = “Cse 220 AnD csE 320 FoRM A twO-CoURSe seQUeNce. 11001101 is a
   BInarY nUMBer.”
   plaintext = “&&&&&&&&&&&&&”
   ab_text = “????????????????????????????????????”
   ab_text_length = 36
   Return value: -1
   Updated plaintext: &&&&&&&&&&&&&
   Updated ab text: “????????????????????????????????????”
   Academic Honesty Policy
   Academic honesty is taken very seriously in this course. By submitting your work to Blackboard you indicate
   your understanding of, and agreement with, the following Academic Honesty Statement:

4. I understand that representing another person’s work as my own is academically dishonest.
5. I understand that copying, even with modifications, a solution from another source (such as the web or
   another person) as a part of my answer constitutes plagiarism.
6. I understand that sharing parts of my homework solutions (text write-up, schematics, code, electronic or
   hard-copy) is academic dishonesty and helps others plagiarize my work.
7. I understand that protecting my work from possible plagiarism is my responsibility. I understand the importance
   of saving my work such that it is visible only to me.
   CSE 220 – Spring 2019 Programming Project #2 17
8. I understand that passing information that is relevant to a homework/exam to others in the course (either
   lecture or even in the future!) for their private use constitutes academic dishonesty. I will only discuss
   material that I am willing to openly post on the discussion board.
9. I understand that academic dishonesty is treated very seriously in this course. I understand that the instructor
   will report any incident of academic dishonesty to the College of Engineering and Applied Sciences.
10. I understand that the penalty for academic dishonesty might not be immediately administered. For instance,
    cheating in a homework may be discovered and penalized after the grades for that homework have been
    recorded.
11. I understand that buying or paying another entity for any code, partial or in its entirety, and submitting it as
    my own work is considered academic dishonesty.
12. I understand that there are no extenuating circumstances for academic dishonesty.
    How to Submit Your Work for Grading
    To submit your proj2.asm file for grading:
13. Login to Blackboard and locate the course account for CSE 220.
14. Click on“Assignments”in the left-hand menu and click the link for this assignment.
15. Click the“Browse My Computer”button and locate the proj2.asm file. Submit only that one .asm file.
16. Click the“Submit”button to submit your work for grading.
    Oops, I messed up and I need to resubmit a file!
    No worries! Just follow the steps again. We will grade only your last submission.