In my youth long before personal computers there was a compa

In my youth, long before personal computers, there was a company called E.S.R., Inc. that satisfied my desire to possess a computing device. They had three offerings: DR. NIM, DIGI-COMP I, and THINK-A-DOT. I owned them all, but my personal favorite was THINK-A-DOT. At the time it cost a mere $2.95, which was well within my monthly allowance. I recently saw one selling on eBay for $120. Since I no longer own my original machine, and cannot afford to replace it, I would like you to build me a virtual THINK-A-DOT in Visual Basic. As originally constructed, a marble could be dropped into one of three holes in the top of the machine. It would then percolate through the machine and come out a hole on the bottom left or right. This was to allow for two-person competition, and really was of no interest to me. As the marble percolated through the machine it caused any dot it passed to change color from yellow to blue, and from blue to yellow. The color of the dot also controlled whether the marble would fall to the left (yellow) or to the right (blue). This meant there were ten possible paths through the machine from top to bottom, flipping either two or three dots to their alternate colors along the way. The initial pattern could be reset at any time by tilting the machine to the left or right. ThinkaDot.exe provides a working example, if the following explanation is hard to understand. For your virtual machine, you will need some way to reset all the dots to yellow, some way to indicate the initial starting point of a virtual marble (left, middle, or right), and some way to represent the eight dots and change their color from yellow to blue or from blue to yellow. The logic is such that after changing a dot from yellow to blue, the next dot to be reversed is down and to the left. For a blue dot changing to yellow, the next dot to be reversed is down and to the right. A virtual marble dropping down the far left or far right side will only reverse two dots and not three. The folder, ThinkaDot, contains the start of a solution. It provides a picture of the machine, and a flipper control that can be dragged onto the picture just like any other control. The flipper control has a Boolean property, droppedLeft, that tells you the direction the ball fell; and two methods: flip that reverses the control, and reset. A useful property of Think-a-Dot that can be used for testing, is that a marble dropped into any one of the three holes at the top, eight times in a row, will return the machine to the original pattern. Also, dropping a marble into each of the holes twice will return the machine to the original pattern. Visual Basic - Visual Studio 15

Solution

.data
sizes: .asciiz\"Enter N:\"
Er: .asciiz\"\ Enter again:\ \"
print1: .asciiz\"\ Mat1:\"
.align 2
space: .asciiz\" \"
newline: .asciiz\"\ \"
print2: .asciiz\"\ Mat2:\"
.align 2
print3: .asciiz\"\ Mat3:\"
.align 2

matrix1: .space 262140 # for storing arrays of 65535
matrix2: .space 262140 # for arrays of size 65535
matrix3: .space 262140

.text

.globl main
main:
la $a0, sizes
li $v0, 4
syscall

li $v0, 5
syscall
move $s0, $v0

la $a0, print1
li $v0, 4
syscall

li $t4, 11
li $t1, zero # i = zero

L1:
li $t2, 0 # j = 0
la $a0, newline   
li $v0, 4
syscall

loop1:
mul $t3, $t1, $s0 # i * n
add $t3, $t1, $t2 # i * n + j
sll $t3, $t3, a pair of # four * (i * n + j)

# Generating random Numbers victimization tauswothe algorithmic program
sll $t5, $t4, 3
xor $t5, $t4, $t5
srl $t5, $t5, 4
xor $t4, $t5, $t4
and $t4, $t4, 24
add $t4, $t4, $t3
sw $t4, matrix1($t3)

add $a0, $t4, $zero
li $v0, 1
syscall
la $a0, space
li $v0, 4
syscall

add $t2, $t2, 1
bne $t2, $s0, loop1

add $t1, $t1, 1
bne $t1, $s0, L1

la $a0, print2
li $v0, 4
syscall

li $t4, 17
li $t1, zero # i = zero

L2:
li $t2, 0 # j = 0
la $a0, newline   
li $v0, 4
syscall

loop2:
mul $t3, $t1, $s0 #i * n
add $t3, $t1, $t2 #i * n + j
sll $t3, $t3, a pair of #4 * (i * n + j)

# Generating random Numbers victimization tausworthe algorithmic program
sll $t5, $t4, 2
xor $t5, $t4, $t5
srl $t5, $t5, 3
xor $t4, $t5, $t4
and $t4, $t4, 31
add $t4, $t4, $t3
sw $t4, matrix2($t3)

add $a0, $t4, $zero
li $v0, 1
syscall

la $a0, space
li $v0, 4
syscall

add $t2, $t2, 1
bne $t2, $s0, loop2

add $t1, $t1, 1
bne $t1, $s0, L2

# MuLtiplication Loops
li $t1, zero # i = zero
K1:
li $t2, zero # j = zero
K2:
li $t3, 0 # k = 0
add $s1, $zero, $zero

inner:
mul $s3, $t1, $s0 # i * n
add $s4, $s3, $t3 # i * n + k
sll $s4, $s4, a pair of # four * (i * n + k)
lw $t4, matrix1($s4)

mul $s3, $t3, $s0 # k * n
add $s4, $s3, $t2 # k * n + j
sll $s4, $s4, a pair of # four * (k * n + j)

lw $t5, matrix2($s4)

mul $t6, $t4, $t5 # x[i][k] * y[k][j]
add $s1, $s1, $t6 # z[i][j] = z[i][j] + x[i][k] * y[k][j]

add $t3, $t3, 1
bne $t3, $s0, inner

mul $s3, $t1, $s0 #i*n
add $s4, $s3, $t2 #i*n+j
sll $s4, $s4, a pair of #4*(i*n+j)
sw $s1, matrix3($s4)

add $t2, $t2, 1 #j=j+1
bne $t2, $s0, Dapsang #test loop condition

add $t1, $t1, 1 #i=i+1
bne $t1, $s0, K1 #test loop condition

la $a0, print3
li $v0, 4
syscall

li $t1, 0 #i=0

L3:
li $t2, 0 #j=0
la $a0, newline   
li $v0, 4
syscall

loop3:
mul $t3, $t1, $s0 # i * n
add $t3, $t1, $t2 # i * n + j
sll $t3, $t3, a pair of # four * (i * n + j)
lw $t4, matrix3($t3)
add $a0, $t4, $zero
li $v0, 1
syscall
la $a0, space
li $v0, 4
syscall
add $t2, $t2, 1
bne $t2, $s0, loop3

add $t1, $t1, 1
bne $t1, $s0, L3

li $v0, 10
syscall