A multiplying tool based on the Slonimsky theorem

In the XIX century there were interesting tools for multiplication, built on the basis of the Slonimsky theorem. This is the “Snonad for multiplication” of Slonim and loffe bars. It is impossible to read anything about these tools on the Internet, except for a meager description of the appearance, nothing of a good description of the method of work (in the style of “it worked like this”), borrowed from the book “The History of Computing Machinery” I.A. Apokin, L.E. Maistrov, "Science" 1990 Description does not disclose the principle of operation of devices. The literature referenced by the author of the book, is unacceptably difficult to get. I decided to open the algorithm of the device operation on my own, and for a demonstration - to make my own analogue.

Purpose of writing an article

This article is for those who, like me, are interested in the history of computing technology.
Theoretically, a good description of the specified tools should be in the book “Instruments and Machines for the Mechanical Production of Arithmetic Actions: Description of the Device and Score Score. devices and machines ”/ V.G. von bool. - Moscow: typ. t-va I.N. Kushnerev and Co., 1896. - 244 pp., Ill., Devil .; 24
But I did not get to the Lenin Library, where it is stored, however it does not matter. The main thing is that there is no information on the Internet, and I wanted it to be, because, I hope, I am not the only one who was puzzled by her search.

Why Habr was chosen as an article placement

The article is devoted, albeit ancient, but still computer technology. Therefore, suitable for Habr on topics.
Habr is well indexed, and I need the information provided in the article to be found. In addition, the community will help me to polish the article in terms of the quality of presentation.
')

The source data that I managed to find

On the Internet, I came across a description of an interesting mathematical tool developed by Z.Ya. Slonimsky .

In the middle of the last century, Z.Ya. Slonimsky (1810-1904) proposed a simple multiplying device based on a theorem proved by him. This device made it possible to produce works of any number (the width of which did not exceed the capacity of the device) by any single-digit number. In other words, it was something like a mechanical multiplication table of any number by 2, 3, 4, ..., 9. Later, Slonimsky's theorem was used to create another simple multiplying device (Ioffe countable bars).

On the basis of his theorem, Slonimsky created a table consisting of 280 columns — 9 numbers each. This table is applied to the cylinders, which are the main element of the device. Cylinders can move in two directions: along the axis and around it. There are also two mini-cylinders on the axis on which the cylinder is located. On the surface of one mini-cylinder there are numbers from 0 to 9, and on the surface of another - the letters a, b, c, d and numbers (from 1 to 7).

On the lid of the device are 11 rows of reading windows, in the first (bottom) row you can see the set number (multiplicand). Letters and numbers appear in the second and third rows of windows when setting a multiplicand. Their combination serves as a key for the operator. Thanks to him, he knows which screw and how much to turn. After that, numbers appear in the 4-11th row of the windows: in the 4th row - the product of the multiplicand by 2, in the 5th row - by 3, in 6 - by 4, etc. Thus, we have the work multiplier for all digits of the multiplier. It now remains in the usual way (on paper) to add up these results and obtain the desired product.

Reading this caused me, as probably you, a reaction: nothing is clear. But the description of the Ioffe bars already suggests some thoughts:

Counting bars were offered to Ioffe in 1881. In 1882, they received an honorable review at the All-Russian Exhibition. The principle of working with them is based on the Slonimsky theorem. Ioffe device consisted of 70 tetrahedral bars. This made it possible to place 280 columns of the Slonim table on 280 faces. Each bar and each column was labeled, which used Arabic and Roman numerals and letters of the Latin alphabet. Latin letters and Roman numerals served to indicate the order in which it was necessary to place the bars in order to obtain the product of a multiplicand by a one-bit factor. The resulting works (and there are as many as the digits in the multiplier) were added (just like when using the Slonimsky multiplier) using pencil and paper.

Those. it turns out that, having 280 columns with numbers, one can add up from them a table of products of any arbitrary number into a series of single-digit numbers.

From the same place:

Bool, in 1896, comes to the following conclusion: “Ioffe bars simplify the multiplication of numbers even more than the Napier sticks and their modifications. After the simple witty bars of Luc and Zhanoya, this is the best of the arithmetic multiplication instruments. ”

The bars of Luke and Zhanoya are also an interesting topic, about which there is even less information, but the article is not about them.

Some result was given by the search for the Slonimsky theorem.
Here is what the Bulletin of the Syktyvkar University writes . Ser.1. Issue 13.2011. UDC 512.6, 517.987 “On the 200th anniversary of the creators of computers submitted to the Demidov Prize, Kh.Z. Slonimsky and G. Kummer ". V.P. Odinets

1. Suppose we have a positive integer in the system J with the base r, written one by one a _m a _m-1 ... a ₂ a ₁ . Multiply it sequentially by 1, 2, 3, ..., r-1, and the resulting works will be signed one under the other in compliance with the rules of discharges. As a result, we get m + 1 columns (fill the empty spaces on the left with zeros), each of which contains r-1 digits. The location of the numbers in the column is called the column representation . Multiplying all possible numbers by 1, 2, ..., r-1 generates an infinite number of representations. However, the number of different representations is of course given by the formula

Where φ (n) is the Euler function defined on the set N of natural numbers, whose value (for any n ∈ N) is equal to the number of natural numbers not exceeding n and mutually prime with n.

2. Now let r = 10, i.e. J number system is decimal. Then the product of any fraction enclosed between two neighboring Farieva fractions p _i / q _i and p _{i + 1} / q _{i + 1} by the numbers 1, 2, 3, ..., 9 generates for the integral parts of the numbers obtained the same representation as and for integer parts of the sequence of products on the numbers 1, 2, 3, ... 9 of the Faroev fraction p _i / q _i

The full article is here .

The wording was not useful to me. I did not begin to search for the proof of the theorem, so to speak, I believed Slonimsky for the word. An important moment for my task of this theorem was that "the number of different representations is of course given by the formula ...". And, as follows from the theorem and from the design of the Slonimsky device, for the decimal system there are 280 column representations.

Slonimsky table

To recreate a device that operates on the basis of the same mathematical idea, I obtained the table of Slonimsky according to the algorithm described in the above article.
I armed myself with a firebug and began to calculate.
Further in the article there will be javascript fragments. This language is the basis of my professional activity, so I used it. Nevertheless, I believe that the formulas I used are simple enough so that the specificity of the language does not make them difficult to understand, and in some places I specifically used techniques that are not accepted in JavaScript to make the code more understandable for programmers in other languages.

According to the article, to construct the main Slonimsky table for the decimal number system, the Farey sequence was taken.
F (9) = {0, 1/9, 1/8, 1/7, 1/6, 1/5, 2/9, 1/4, 2/7, 1/3, 3/8, 2 / 5, 3/7, 4/9, 1/2, 5/9, 4/7, 3/5, 5/8, 2/3, 5/7, 3/4, 7/9, 4/5, 5/6, 6/7, 7/8, 8/9, 1}. The 28 numbers of the sequence F (9), except 1, were each multiplied by a series of numbers from 0 to 9 and only whole parts of the resulting works were taken. The resulting columns of numbers are numbered in ascending order of Farey numbers starting from 0.

The values ​​of the table are obtained by the formula

B[c][r] = Math.floor(F[c]*r); 

Here c is the column number, r is the row number.

Base Table of Slonim (B)

r \ c	0	one	2	3	four	five	6	7	eight	9	ten	eleven	12	13	14	15	sixteen	17	18	nineteen	20	21	22	23	24	25	26	27
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
one	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	0	0	0	0	0	0	0	0	0	0	0	0	0	one	one	one	one	one	one	one	one	one	one	one	one	one	one
3	0	0	0	0	0	0	0	0	0	one	one	one	one	one	one	one	one	one	one	2	2	2	2	2	2	2	2	2
four	0	0	0	0	0	0	0	one	one	one	one	one	one	one	2	2	2	2	2	2	2	3	3	3	3	3	3	3
five	0	0	0	0	0	one	one	one	one	one	one	2	2	2	2	2	2	3	3	3	3	3	3	four	four	four	four	four
6	0	0	0	0	one	one	one	one	one	2	2	2	2	2	3	3	3	3	3	four	four	four	four	four	five	five	five	five
7	0	0	0	one	one	one	one	one	2	2	2	2	3	3	3	3	four	four	four	four	five	five	five	five	five	6	6	6
eight	0	0	one	one	one	one	one	2	2	2	3	3	3	3	four	four	four	four	five	five	five	6	6	6	6	6	7	7
9	0	one	one	one	one	one	2	2	2	3	3	3	3	four	four	five	five	five	five	6	6	6	7	7	7	7	7	eight

To obtain the complete Slonim table, an auxiliary table P was constructed, which is a multiplication table of numbers from 0 to 9 in the Pythagorean representation.

 P[c][r] = c*r; 

r \ c	0	one	2	3	four	five	6	7	eight	9
0	0	0	0	0	0	0	0	0	0	0
one	0	one	2	3	four	five	6	7	eight	9
2	0	2	four	6	eight	ten	12	14	sixteen	18
3	0	3	6	9	12	15	18	21	24	27
four	0	four	eight	12	sixteen	20	24	28	32	36
five	0	five	ten	15	20	25	thirty	35	40	45
6	0	6	12	18	24	thirty	36	42	48	54
7	0	7	14	21	28	35	42	49	56	63
eight	0	eight	sixteen	24	32	40	48	56	64	72
9	0	9	18	27	36	45	54	63	72	81

Each column of table B is vectorially combined with each column of table P. Thus, an intermediate table DU containing 280 columns is obtained.

 DU[b*10+p][r] = B[b][r] + P[p][r]; 

On its basis, two tables U and D were constructed, containing, respectively, the digits of the units and the tens of the amounts received.

 U[c][r] = DU[c][r] % 10; D[c][r] = Math.floor(DU[c][r]/10); 

It has been found that the table of units (U) contains non-repeating columns, whereas all columns of the table of tens (D) are found in table U and table B.

Thus, table U exhausts all generated columns. Therefore, it is the complete table of Slonim.

For the convenience of further work, I marked which column of table B each column of D coincides with, and with the same numbers I marked columns of the same table number U (row q of both tables), and for even more convenience I entered the Q array containing the specified values, under the numbers corresponding to the columns in tables D and U.

Autopsy algorithm

First, I noticed that the column group with b = 0 of the DU table is the same as the Pythagorean table.

c	0	one	2	3	four	five	6	7	eight	9
b	0	0	0	0	0	0	0	0	0	0
r \ p	0	one	2	3	four	five	6	7	eight	9
0	0	0	0	0	0	0	0	0	0	0
one	0	one	2	3	four	five	6	7	eight	9
2	0	2	four	6	eight	ten	12	14	sixteen	18
3	0	3	6	9	12	15	18	21	24	27
four	0	four	eight	12	sixteen	20	24	28	32	36
five	0	five	ten	15	20	25	thirty	35	40	45
6	0	6	12	18	24	thirty	36	42	48	54
7	0	7	14	21	28	35	42	49	56	63
eight	0	eight	sixteen	24	32	40	48	56	64	72
9	0	9	18	27	36	45	54	63	72	81

The second observation: if you select columns with p = 0 from table U, the table composed of them coincides with table B.

c	0	ten	20	thirty	40	50	60	70	80	90	100	110	120	130
b	0	one	2	3	four	five	6	7	eight	9	ten	eleven	12	13
r \ p	0	0	0	0	0	0	0	0	0	0	0	0	0	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
one	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	0	0	0	0	0	0	0	one	one	one	one	one
four	0	0	0	0	0	0	0	one	one	one	one	one	one	one
five	0	0	0	0	0	one	one	one	one	one	one	2	2	2
6	0	0	0	0	one	one	one	one	one	2	2	2	2	2
7	0	0	0	one	one	one	one	one	2	2	2	2	3	3
eight	0	0	one	one	one	one	one	2	2	2	3	3	3	3
9	0	one	one	one	one	one	2	2	2	3	3	3	3	four
q	0	0	0	0	0	0	0	0	0	0	0	0	0	0

Continuation

c	140	150	160	170	180	190	200	210	220	230	240	250	260	270
b	14	15	sixteen	17	18	nineteen	20	21	22	23	24	25	26	27
r \ p	0	0	0	0	0	0	0	0	0	0	0	0	0	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
one	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	one	one	one	one	one	one	one	one	one	one	one	one	one	one
3	one	one	one	one	one	2	2	2	2	2	2	2	2	2
four	2	2	2	2	2	2	2	3	3	3	3	3	3	3
five	2	2	2	3	3	3	3	3	3	four	four	four	four	four
6	3	3	3	3	3	four	four	four	four	four	five	five	five	five
7	3	3	four	four	four	four	five	five	five	five	five	6	6	6
eight	four	four	four	four	five	five	five	6	6	6	6	6	7	7
9	four	five	five	five	five	6	6	6	7	7	7	7	7	eight
q	0	0	0	0	0	0	0	0	0	0	0	0	0	0

So each column D [i] of table D is included in table U as a column for which b = Q [i], p = 0.

It is obvious that the last digit of the product of two numbers is equal to the last digit of the product of the last digits of these numbers. Therefore, if I take from the zero group of the table U a column with the number equal to the last digit of the multiplied, then this will be the last column of the compiled worksheet of the multiplied number by a series of single-digit numbers.

Then I assumed that q is the number of the group from which I must take a column for the next digit. I decided to start with group 0.
Conducted a computational experiment using FireBug - sort of how it turns out.

Take, for example, a random four-digit (so that the experiment was not too simple) number. When preparing the article, I did it like this:

 value = (100 + Math.floor(Math.random()*(999-100)))*10 + 1 + Math.floor(Math.random()*(9-1)); 

Such a formula guarantees that a number not less than 1000 will be obtained and that there will not be zero in the unit discharge.
At the extreme assembly of the article, randomly gave me value = 3212.
Take from group 0 of table U column 2:

c	2
b	0
r \ p	2
0	0
one	2
2	four
3	6
four	eight
five	0
6	2
7	four
eight	6
9	eight
q	five

We see that q = 5 for it. Now for the next digit we take from group 5 column 1:

c	51	2
b	five	0
r \ p	one	2
0	0	0
one	one	2
2	2	four
3	3	6
four	four	eight
five	6	0
6	7	2
7	eight	four
eight	9	6
9	0	eight
q	one	five

For this column q = 1. We continue the table in a similar way, and we get:

c	53	12	51	2
b	five	one	five	0
r \ p	3	2	one	2
0	0	0	0	0
one	3	2	one	2
2	6	four	2	four
3	9	6	3	6
four	2	eight	four	eight
five	6	0	6	0
6	9	2	7	2
7	2	four	eight	four
eight	five	6	9	6
9	eight	9	0	eight
q	eight	five	one	five

The numbers have run out, the next q = 8. Obviously, it is necessary to take the zero column from group 8. We get:

c	80	53	12	51	2
b	eight	five	one	five	0
r \ p	0	3	2	one	2
0	0	0	0	0	0
one	0	3	2	one	2
2	0	6	four	2	four
3	0	9	6	3	6
four	one	2	eight	four	eight
five	one	6	0	6	0
6	one	9	2	7	2
7	2	2	four	eight	four
eight	2	five	6	9	6
9	2	eight	9	0	eight
q	0	eight	five	one	five

It is easy to see that in the rows of this table are the works of our number 3212 by 0, 1, 2, ... 9.

Parsing the experiment

It was harder to figure out why this works.
So, we have 28 groups (from 0 to 27) with 10 columns each. Groups are assigned the same numbers as the columns of table B.
Tables DU, U and D in row b contain the group number, in row p the number of the column in the group.

We introduce the functions:
The function of multiplying a number by a vector {0; one; 2; 3; four; five; 6; 7; eight; 9} (vector represented by an array)

 function mul(n){ var result = new Array(10); for(var i=0; i<10; ++i){ result[i]=n*i; } return result; } 

The function of vector addition of two arrays

 function sum(a, b){ var result = new Array(10); for(var i=0; i<10; ++i){ result[i]=a[i]+b[i]; } return result; } 

The function of obtaining an array containing the values ​​of the digit units of the values ​​of the original array

 function unit(a){ var result = new Array(10); for(var i=0; i<10; ++i){ result[i]=a[i] % 10; } return result; } 

The function of obtaining an array containing the discharge values ​​of tens of values ​​of the original array

 function deca(a){ var result = new Array(10); for(var i=0; i<10; ++i){ result[i]=Math.floor(a[i] / 10); } return result; } 

It is easy to compare the formulas and notice that each column of the table P is nothing but the result of the function mul for the column number;
columns of tables D and U are derived from columns of table DU using the functions unit and deca, respectively;
each column of the table DU is obtained by summing one column of table B and one column of table P, which corresponds to the use of the sum function.

Recall the multiplication algorithm in a column of a multi-digit number on a single-digit one:

Let be
a _n a _n-1 ... a ₁ a ₀ - multiplicable, written bitwise;
b is a one-bit multiplier;
with _{n + 1} c _n ... c ₁ c ₀ - the result is written bitwise (we assume that the result is one digit longer than the multiplicand, in most cases it will be so, in the others - no one has yet died of the leading zero);
m ₀ , m ₁ , ... m _n - values ​​transferred to the most significant digit (when calculating on paper, they are written “up”);
floor - rounding function down;
% - the operation of obtaining the remainder of the division.
The variable x will be used as local and recalculated for each digit.

1. Take from the multiplication table (it is in each of us in memory) the product of the zero digit of the multiplicative factor:
x = a ₀ * b;
the digit of the units of the number x without changes is written to the result: c ₀ = x% 10;
the tens digit of the number x is written “up”: m ₀ = floor (x / 10).

2. From the multiplication table, take the product of the first digit multiplied by a factor and add the value “from above” to it:
x = a ₁ * b + m ₀
discharge of units - write to the result: c ₁ = x% 10;
tens of digits - write “up”: m ₁ = floor (x / 10).

3. We do the same for discharges from 2 to n:
x = a _i * b + m _i-1
c _i = x% 10;
m _i = floor (x / 10).

4. The value obtained during the calculation of discharge _n will give us the last digit of the result:
c _{n + 1} = m _n .

I guess everyone agrees? There are no errors in the description? Then we think further:

The Slonimsky table is used to obtain products of an arbitrary number by a series of numbers from 0 to 9.
If we decided to multiply in a column, then we would multiply the multiplicable number ten times and get on the set with _{n + 1} c _n ... c ₁ c ₀ and m ₀ , m ₁ , ... m _n for each of the ten multipliers.
Since we want to open the Slonimsky algorithm, we also introduce an array j ₀ ... j _{n + 1} , in which we will store the column numbers of the table U corresponding to the columns of the multiplication result.

To simplify the form of the record, we will use the functions we have entered, and go through the same points of the above algorithm:
1. Calculate
x = mul (a ₀ );
Obviously, x coincides with the column No. a _{0 of} the Pythagorean table (P) and, interestingly, with the column p = a ₀ , b = 0 of the table DU. In the tables DU, U and D the column number is calculated as b * 10 + p, therefore
x = DU [a ₀ ]
Now we need units to write in the result, and tens to write "up":
c ₀ = unit (x);
m ₀ = deca (x);
in this case, c ₀ and m ₀ are arrays.
Note that c _{0 is} obtained in the same way as column p = a ₀ , b = 0 of table U, and m ₀ as the corresponding column of table D.
We write:
j ₀ = a ₀ ;
c ₀ = U [j ₀ ];
m ₀ = D [j ₀ ].

2. Now we take the next level. We need to calculate the product of a ₁ by the vector, and then vectorially add to the resulting array an array of m ₀ :
x = sum (mul (a ₁ ), m ₀ );
Parse this formula:
mul (a ₁ ) is the same as column P [a ₁ ].

In step 1, it was calculated:
m ₀ = D [j ₀ ].
Recall now that for each column of table D, the number q was found under which this column is included in table B. For convenience, we recorded this number in the row q of the tables U and D and in the array Q.
Now we write:
m ₀ = D [j ₀ ] = B [Q [j ₀ ]];
May programmers and mathematicians forgive me for such a mixture of styles.

Both items are dismantled. Now remember the amount. One of the terms is a member of table P, and the other is table B. We have calculated all sums for this case and are included in table DU.
Therefore, the required array must match the column of the table DU, for which p = a ₁ , b = Q [j ₀ ]:
x = DU [Q [j ₀ ] * 10 + a ₁ ].
Now we need units and tens of members x again:
c ₁ = unit (x);
m ₁ = deca (x);
and tables U and D will help us in this again.

Let's summarize the second step:
j ₁ = Q [j ₀ ] * 10 + a ₁ ;
c ₁ = U [j ₁ ];
m ₁ = D [j ₁ ].

3. You can already notice the pattern:
x = sum (mul (a _i ), m _i-1 );
and since:
mul (a _i ) = P [a _i ],
m _i-1 = D [j _i-1 ] = B [Q [j _i-1 ]];
then:
x = DU [Q [j _i-1 ] * 10 + a _i ].
Consequently:
j _i = Q [j _i-1 ] * 10 + a _i ;
c _i = U [j _i ];
m _i = D [j _i ].

4. Now let's see what we do with m _n .
The last carry of the discharge is the most significant bit of the result. But we need to select a column of the U table.
Let's analyze:
m _n = D [j _n ].
D [j _n ] enters table U as a column b = Q [j _n ], p = 0, i.e.
D [j _n ] = U [Q [j _n ] * 10].
Consequently:
j _{n + 1} = Q [j _n ] * 10;
c _{n + 1} = U [j _{n + 1} ].
Since no product of one-digit numbers can give more than two-digit number, the array m _{n + 1} will contain only zeros. The calculation is complete.

Now let's pile together the equations for j _i :
j ₀ = a ₀ ;
j _i = Q [j _i-1 ] * 10 + a _i ;
j _{n + 1} = Q [j _n ] * 10.
They come down to one equation.
j _i = Q [j _i-1 ] * 10 + a _i ,
if you accept that
a _{n + 1} = 0 (which is equivalent to assigning a leading zero to a multiplicative number),
Q [j _-1 ] = 0.

This means that in order to add the product table of the numbers a _n a _n-1 ... a ₁ a ₀ to single-digit numbers from the columns of the table U, each time you need to take the column p = a _i from the group b = Q [j _i-1 ] and the row q of the same table column will tell us which group of columns will be next, and we need to start working with the group of columns 0.

The algorithm demonstrated in the experiment is derived analytically.

I summarize:

The algorithm found can be described as automaton, where the input line is a multiplied number, readable from right to left (from low-order bits to high-order ones), and states are the numbers of column groups. At each stage of the work, we take from the group under the state number the column under the number of the next digit and move to the state under the number from the row q of this column.
For a correct completion of the algorithm, a leading zero must be added to the multiplier.

Material implementation

This section has no special significance for the article; I could not include it. But let it be for show.

Neither the “projectile” of Slonim, nor Ioffe’s bars were restored by me. Recreating authentic copies requires more information about the products themselves.

I created my own version of the instrument for the purpose of its operation on RI of live action for epochs for which the product would not be an anachronism, as well as a full-scale demonstration of the operation algorithm.
Authenticity to any historical model is not assumed. The focus was on ease of use.

From the point of view of operation, the columns should be placed on the carrier in such a way that they can be easily sorted both by groups and by numbers. Moreover, based on the algorithm of work, you first need to select the desired group, and then the desired column.

I must note that it is convenient to place the columns on the four-sided bars, like Ioffe, I did not succeed. I suspect that the loffe bars were not so comfortable.

28 groups of 10 columns are conveniently placed on double-sided rails. In addition, each group of columns was applied on its own five rails.

To reduce the amount of information applied to the slats, the zero line of the table was not applied to the slats, since it contains the number 0 in all columns. The number of the column was not applied separately, because it coincides with the number in the first row of the table. The number of the group to which the rake belongs was marked with Roman numerals on the side faces of the rake. It is needed only for sorting the rails in case of their random mixing (which should be avoided during operation).

The q value of the column is plotted on each rail below the horizontal dividing line.

The slats are made of 50x2 mm aluminum strip, which for this purpose was cut with an electric jigsaw about 4-6 mm each (too narrow were rejected, too wide either were eaten away by a grinding disc, or were also rejected).
Figures are engraved with a mill.
For storage of the rails, a wooden organizer, 50x40 mm, was drilled from pine timber. Yes, I know that you can think better, but there were 2 days left before the game, and after engraving, 2,800 digits were running out.
The numbers of groups and columns are printed on the organizer with a gel pen.

Because of the mysterious glitches with the disappearance of pictures, photos were added using the comment habrahabr.ru/post/232255/#comment_7940351

Sources

1. Bulletin of the University of Syktyvkar. Ser.1. Issue 13.2011. UDC 512.6, 517.987 “On the 200th anniversary of the creators of computers submitted to the Demidov Prize, Kh.Z. Slonimsky and G. Kummer ". V.P. Odinets ;
2. Slonimsky's theorem and simple computing devices based on it .

PS May the Spirit of the Machine bless your server, for it has survived sending almost 200kb of code, and taking into account escaping, all 500.