##:/
This code uses the numbers
/(General)
one hundred, /(The stack pointer)
zero,
one,
/(Numeric I/O)
ten, /(10 = '\n')
/(5) forty seven, /('0'-1)
forty eight, /('0')
two, /(The character that was read, initialiser doesn't matter)
three, /(The value to be I/Oed. aka NIOVal, initialiser doesn't matter)
/(Program)
two hundred and two, /(Return reference for after_reading_case_count)
/(10) two hundred and three, /(Return reference for after_reading_device_count)
two hundred and four, /(Return reference for after_reading_snap_count)
two hundred and five, /(Return reference for after_writing_case_number)
sixty seven, /('C')
ninety seven, /('a')
/(15) one hundred and fifteen, /('s')
one hundred and one, /('e')
thirty two, /(' ')
thirty five, /('#')
fifty eight, /(':' = '9'+1)
/(20) seventy nine, /('O')
seventy, and /('F')
seventy eight. /('N')
/(The number of cases)
/(The current case number)
/(25) /(The number of snappers)
/(The number of snaps)
/(The number of snaps required for a full cycle)
This code
/(General)
always goes to the first label, /(Goes to the trampoline)
/(Numeric I/O)
always goes to the second label, /(Read a value)
sometimes goes to the second label if the first logical operation is true, /(Keep skipping nondigits)
sometimes goes to the third label if the second logical operation is true, /(Keep reading digits)
/(5) always goes to the fourth label, /(Write a value)
sometimes goes to the fifth label if the third logical operation is true, /(Keep pushing digits to print)
sometimes goes to the sixth label if the fourth logical operation is true, /(Keep printing digits)
/(Program)
sometimes goes to the seventh label if the fifth condition is true, /(Return to after_reading_case_count)
sometimes goes to the eighth label if the sixth condition is true, /(Return to after_reading_device_count)
/(10) sometimes goes to the nineth label if the seventh condition is true, /(Return to after_reading_snap_count)
sometimes goes to the tenth label if the eighth condition is true, /(Return to after_writing_case_number)
sometimes goes to the fifteenth label if the nineth condition is true, /(Stop after last case)
always goes to the eleventh label, /(To top of main loop)
always goes to the twelveth label, /(Loop computing snaps in cycle)
/(15) sometimes goes to the thirteenth label if the tenth condition is true, and /(Break of computing snaps in cycle)
sometimes goes to the fourteenth label if the eleventh condition is true. /(Switch to printing "N" instead of "FF")
This code writes
/(Numeric I/O)
the cell indexed by the first number as a character, /(Write a digit from the stack)
/(Program)
the thirteenth number as a character, /(Write 'C')
the fourteenth number as a character, /(Write 'a')
the fifteenth number as a character, /(Write 's')
/(5) the sixteenth number as a character, /(Write 'e')
the seventeenth number as a character, /(Write ' ')
the eighteenth number as a character, /(Write '#')
the nineteenth number as a character, /(Write ':')
the twentieth number as a character, /(Write 'O')
/(10) the twentyfirst number as a character, /(Write 'F')
the twentysecond number as a character, and /(Write 'N')
the fourth number as a character. /(Write '\n')
This code reads
/(Numeric I/O)
the seventh number as a character. /(Read a digit)
This code uses the sums
/(Numeric I/O)
of the first product and the second ordered difference, /(Sum to place in NIOVal)
of the cell indexed by the first number and the sixth number, /(Head of stack as ASCII)
/(Program)
of the first number and the third number, /(Stack pointer plus one)
of the twentyfourth number and the third number, /(Case index plus one)
/(5) of the twentyseventh number and the twentyseventh number, and /(Twice snaps in cycle)
of the twentysixth number and the third number. /(One more than the number of snaps)
This code uses
/(Numeric I/O)
the condition that the fifth number is less than the seventh number, /(The character read is >= '0')
the condition that the seventh number is less than the nineteenth number, /(The character read is <= '9')
the condition that the eighth number is equal to the second number, /(NIOVal is zero, i.e. we have pushed all its digits)
the condition that the cell indexed by the first number is equal to the fourth number, /(We have finished printing digits)
/(Program)
/(5) the condition that the cell indexed by the first number is equal to the nineth number, /(Return label for after_reading_case_count)
the condition that the cell indexed by the first number is equal to the tenth number, /(Return label for after_reading_device_count)
the condition that the cell indexed by the first number is equal to the eleventh number, /(Return label for after_reading_snap_count)
the condition that the cell indexed by the first number is equal to the twelveth number, /(Return label for after_writing_case_number)
the condition that the twentyfourth number is equal to the twentythird number, /(Have just done the last case)
/(10) the condition that the twentyfifth number is equal to the second number, and /(Finished computing snaps in cycle)
the condition that the third product is equal to the twentysixth number. /(The light is on)
This code uses fifteen labels.
/(General)
/(The trampoline, jumps to a label based on the head of the stack)
/(Numeric I/O)
/(Numeric read into NIOVal)
/(Reading digits)
/(Numeric write from NIOVal)
/(5) /(Pushing digits)
/(Printing digits)
/(Program)
/(Return label for after_reading_case_count)
/(Return label for after_reading_device_count)
/(Return label for after_reading_snap_count)
/(10) /(Return label for after_writing_case_number)
/(Top of the main loop)
/(Top of the loop computing snaps in cycle)
/(After loop computing snaps in cycle)
/(Jump here if the light is on)
/(15) /(End of program)
This code uses the ordered differences
/(General)
between the first number and the third number, /(One less than the stack pointer)
/(Numeric I/O)
between the seventh number and the sixth number, /(The numeric value of the character read)
between the eighth number and the second product, and /(NIOVal % 10)
/(Program)
between the twentyfifth number and the third number. /(One less than the number of devices)
This code assigns
/(General)
the third sum to the first number, /(Increment the stack pointer)
the first ordered difference to the first number, /(Decrement the stack pointer)
/(Numeric I/O)
the second number to the eighth number, /(Clear NIOVal)
the first sum to the eighth number, /(Update NIOVal with the new digit)
/(5) the third ordered difference to the cell indexed by the first number, /(Put the last digit of NIOVal on the stack)
the fourth number to the cell indexed by the first number, /(Put a ten on the stack to mark the last digit)
the first ratio to the eighth number, /(Divide NIOVal by 10)
the second sum to the cell indexed by the first number, /(Convert the head of the stack to ASCII)
/(Program)
the nineth number to the cell indexed by the first number, /(Set return point to after_reading_case_count)
/(10) the tenth number to the cell indexed by the first number, /(Set return point to after_reading_device_count)
the eleventh number to the cell indexed by the first number, /(Set return point to after_reading_snap_count)
the twelveth number to the cell indexed by the first number, /(Set return point to after_writing_case_number)
the eighth number to the twentythird number, /(Set the case count from NIOVal)
the eighth number to the twentyfifth number, /(Set the number of snappers from NIOVal)
/(15) the eighth number to the twentysixth number, /(Set the number of snaps from NIOVal)
the twentyfourth number to the eighth number, /(Set NIOVal from the case index)
the second number to the twentyfourth number, /(Initialise the case index)
the third number to the twentyseventh number, /(Initialise snaps in cycle)
the fourth sum to the twentyfourth number, /(Increment the case index)
/(20) the fifth sum to the twentyseventh number, /(Double snaps in cycle)
the fourth ordered difference to the twentyfifth number, and /(Decrement the device count)
the sixth sum to the twentysixth number. /(Increment the snap count)
This code uses the products
/(Numeric I/O)
of the eighth number and the fourth number, /(NIOVal * 10)
of the first ratio and the fourth number, and /(NIOVal / 10 * 10)
/(Program)
of the second ratio and the twentyseventh number. /(Number of snaps / snaps in cycle * snaps in cycle)
This code implements
/(Program)
the first assignment,
the nineth assignment,
the second jump,
the seventh label,
the second assignment,
the thirteenth assignment,
the seventeenth assignment,
the eleventh label,
the twelveth jump,
the nineteenth assignment,
the first assignment,
the tenth assignment,
the second jump,
the eighth label,
the fourteenth assignment,
the eleventh assignment,
the second jump,
the nineth label,
the second assignment,
the fifteenth assignment,
the eighteenth assignment,
the twelveth label,
the fifteenth jump,
the twentieth assignment,
the twentyfirst assignment,
the fourteenth jump,
the thirteenth label,
the twentysecond assignment,
the second output,
the third output,
the fourth output,
the fifth output,
the sixth output,
the seventh output,
the sixteenth assignment,
the first assignment,
the twelveth assignment,
the fifth jump,
the tenth label,
the second assignment,
the eighth output,
the sixth output,
the nineth output,
the sixteenth jump,
the tenth output,
the tenth output,
the twelveth output,
the thirteenth jump,
the fourteenth label,
the eleventh output,
the twelveth output,
the thirteenth jump,
/(Numeric I/O)
the second label,
the first input,
the third assignment,
the third jump,
the third label,
the fourth assignment,
the first input,
the fourth jump,
the first jump,
the fourth label,
the first assignment,
the sixth assignment,
the fifth label,
the first assignment,
the fifth assignment,
the seventh assignment,
the sixth jump,
the sixth label,
the eighth assignment,
the first output,
the second assignment,
the seventh jump,
the second assignment,
the first jump,
/(General)
the first label,
the eighth jump,
the nineth jump,
the tenth jump,
the eleventh jump, and
the fifteenth label.
This code uses the ratios
/(Numeric I/O)
of the eighth number to the fourth number, and /(NIOVal / 10)
/(Program)
of the twentysixth number to the twentyseventh number. /(Number of snaps / snaps in cycle)
This code uses the logical operations
/(Numeric I/O)
of not the first condition or not the second condition, /(The character read is not a digit)
of not the first logical operation or not the first logical operation, /(The character read is a digit)
of not the third condition or not the third condition, and /(NIOVal != 0)
of not the fourth condition or not the fourth condition. /(The head of the stack is 10, end of digits)
This code is cool.