No message set (use ?m= to set it), using "MP kicks ass!" as a default.
No bitsize of result set (use &b= to set it), using 512 bits as a default.

The [M]essage chosen is MP kicks ass!, its bit-value is
1001101101000010000011010111101001110001111010111110011100000110000111100111110011100001

The [S]tate machine starts as 0

The [R]esult ring is 64 bits long ; it starts as
0000000000000000000000000000000000000000000000000000000000000000

This was the initialization step. From here on the algorithm will be processing the message and explain its actions.

### Step 1

We find ourselves at position 0 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1.
As R is 64 bits long and we are on position 0, we take the 0-th bit of R, which is 0 and we compare it with the 0-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0000000000000000000000000000000000000000000000000000000000000000

### Step 2

We find ourselves at position 1 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10
and we xor all its bits with the position-th elements of R. R thus becomes
R=0100000000000000000000000000000000000000000000000000000000000000
As R is 64 bits long and we are on position 1, we take the 1-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0000000000000000000000000000000000000000000000000000000000000000
S=01

### Step 3

We find ourselves at position 2 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000100000000000000000000000000000000000000000000000000000000000
As R is 64 bits long and we are on position 2, we take the 2-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010100000000000000000000000000000000000000000000000000000000000

### Step 4

We find ourselves at position 2 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0100
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010001000000000000000000000000000000000000000000000000000000000
As R is 64 bits long and we are on position 2, we take the 2-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0000001000000000000000000000000000000000000000000000000000000000
S=1011

### Step 5

We find ourselves at position 3 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0010.
As R is 64 bits long and we are on position 3, we take the 3-th bit of R, which is 0 and we compare it with the 3-th bit of S, which is 0
Because they are equal we flip R's bit.
R=0001001000000000000000000000000000000000000000000000000000000000

### Step 6

We find ourselves at position 4 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0010.
As R is 64 bits long and we are on position 4, we take the 4-th bit of R, which is 0 and we compare it with the 0-th bit of S, which is 0
Because they are equal we flip R's bit.
R=0001101000000000000000000000000000000000000000000000000000000000

### Step 7

We find ourselves at position 5 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 00100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1001111000000001000010000000000000000000000000000000000000000000
As R is 64 bits long and we are on position 5, we take the 5-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1001101000000001000010000000000000000000000000000000000000000000
S=11011

### Step 8

We find ourselves at position 6 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 00111.
As R is 64 bits long and we are on position 6, we take the 6-th bit of R, which is 1 and we compare it with the 1-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0011000010101011101000101010101010101010101010101010101010101010

### Step 9

We find ourselves at position 7 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 10010.
As R is 64 bits long and we are on position 7, we take the 7-th bit of R, which is 0 and we compare it with the 2-th bit of S, which is 0
Because they are equal we flip R's bit.
R=0011000110101011101000101010101010101010101010101010101010101010

### Step 10

We find ourselves at position 8 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100100
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011000100101011001000101010101000101010001010101010101010101010
As R is 64 bits long and we are on position 8, we take the 8-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011000110101011001000101010101000101010001010101010101010101010

### Step 11

We find ourselves at position 8 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1001000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011000100101011101000101010101010101010101010100010101010101010
As R is 64 bits long and we are on position 8, we take the 8-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011000110101011101000101010101010101010101010100010101010101010

### Step 12

We find ourselves at position 8 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10010000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011000100101011001000101010101000101010001010101010101000101010
As R is 64 bits long and we are on position 8, we take the 8-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011000110101011001000101010101000101010001010101010101000101010

### Step 13

We find ourselves at position 8 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100100000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011000100101011101000101010101010101010101010100010101010101010
As R is 64 bits long and we are on position 8, we take the 8-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1011000110101011101000101010101010101010101010100010101010101010

### Step 14

We find ourselves at position 8 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1001000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011000110101011001000101010101000101010001010101010101000101010
As R is 64 bits long and we are on position 8, we take the 8-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0011000100101011001000101010101000101010001010101010101000101010
S=0110111111

### Step 15

We find ourselves at position 9 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1110110000.
As R is 64 bits long and we are on position 9, we take the 9-th bit of R, which is 0 and we compare it with the 9-th bit of S, which is 0
Because they are equal we flip R's bit.
R=0011000101101011001000101010101000101010001010101010101000101010

### Step 16

We find ourselves at position 10 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 11101100000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011001101101011101000101000100000100010001010101010101000100010
As R is 64 bits long and we are on position 10, we take the 10-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0011001101001011101000101000100000100010001010101010101000100010
S=00010011111

### Step 17

We find ourselves at position 11 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 000100111110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011001101011011101000001000100000100010001000101010101101100010
As R is 64 bits long and we are on position 11, we take the 11-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1011001101001011101000001000100000100010001000101010101101100010
S=111011000001

### Step 18

We find ourselves at position 12 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1110110000010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011001111001011001010001000100010101010001010101010101111100010
As R is 64 bits long and we are on position 12, we take the 12-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1011001111000011001010001000100010101010001010101010101111100010
S=0001001111101

### Step 19

We find ourselves at position 13 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 00010011111010
and we xor all its bits with the position-th elements of R. R thus becomes
R=0111001111000110001010001010100010101010011010101010001111100010
As R is 64 bits long and we are on position 13, we take the 13-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0111001111000010001010001010100010101010011010101010001111100010
S=11101100000101

### Step 20

We find ourselves at position 14 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 01101100000101.
As R is 64 bits long and we are on position 14, we take the 14-th bit of R, which is 1 and we compare it with the 0-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1101100101101000100000100000001000000000110000000000100101001000

### Step 21

We find ourselves at position 15 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 011011000001010
and we xor all its bits with the position-th elements of R. R thus becomes
R=0101100001101000101000000010001000000000100001000000000111001000
As R is 64 bits long and we are on position 15, we take the 15-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0101100001101001101000000010001000000000100001000000000111001000

### Step 22

We find ourselves at position 15 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0110110000010100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101100101101001100000100000001001000000110000000000100101001000
As R is 64 bits long and we are on position 15, we take the 15-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1101100101101000100000100000001001000000110000000000100101001000
S=1001001111101011

### Step 23

We find ourselves at position 16 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10010011111010110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101100101101000000000100000001011000000110000001000100101001000
As R is 64 bits long and we are on position 16, we take the 16-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101100101101000100000100000001011000000110000001000100101001000

### Step 24

We find ourselves at position 16 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100100111110101100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101100101101000100000100000001001000000110000000000100101001000
As R is 64 bits long and we are on position 16, we take the 16-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1101100101101000000000100000001001000000110000000000100101001000
S=011011000001010011

### Step 25

We find ourselves at position 17 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0110110000010100110
and we xor all its bits with the position-th elements of R. R thus becomes
R=0101100111100000000000100100001001000010111000100011100001001001
As R is 64 bits long and we are on position 17, we take the 17-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0101100111100000010000100100001001000010111000100011100001001001

### Step 26

We find ourselves at position 17 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01101100000101001100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100101101000010000100000001001000000110000000000100101001000
As R is 64 bits long and we are on position 17, we take the 17-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1100100101101000000000100000001001000000110000000000100101001000
S=10010011111010110011

### Step 27

We find ourselves at position 18 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100100111110101100110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101111101000001000100010001011001000011000000010100101001000
As R is 64 bits long and we are on position 18, we take the 18-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1100101111101000000000100010001011001000011000000010100101001000
S=011011000001010011001

### Step 28

We find ourselves at position 19 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0110110000010100110010
and we xor all its bits with the position-th elements of R. R thus becomes
R=0100111111001001000000001010011011000000001100000000100100001010
As R is 64 bits long and we are on position 19, we take the 19-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0100111111001001000100001010011011000000001100000000100100001010

### Step 29

We find ourselves at position 19 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01101100000101001100100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101111101000000100100010001011101000011000000010100101001000
As R is 64 bits long and we are on position 19, we take the 19-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1100101111101000000000100010001011101000011000000010100101001000
S=10010011111010110011011

### Step 30

We find ourselves at position 20 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 00110111011111011110110.
As R is 64 bits long and we are on position 20, we take the 20-th bit of R, which is 0 and we compare it with the 20-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1100101111101000000000100010001011101000011000000010100101001000

### Step 31

We find ourselves at position 21 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 11100010001010001011100.
As R is 64 bits long and we are on position 21, we take the 21-th bit of R, which is 0 and we compare it with the 21-th bit of S, which is 0
Because they are equal we flip R's bit.
R=1100101111101000000001100010001011101000011000000010100101001000

### Step 32

We find ourselves at position 22 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 111000100010100010111000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1110100111001010000001101000000011100000011000101000001101101000
As R is 64 bits long and we are on position 22, we take the 22-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1110100111001010000001001000000011100000011000101000001101101000
S=000111011101011101000111

### Step 33

We find ourselves at position 23 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 100111011101000010111000.
As R is 64 bits long and we are on position 23, we take the 23-th bit of R, which is 0 and we compare it with the 23-th bit of S, which is 0
Because they are equal we flip R's bit.
R=1110100111001010000001011000000011100000011000101000001101101000

### Step 34

We find ourselves at position 24 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1001110111010000101110000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0110100111001010100001011000000001100000011000101000001101101000
As R is 64 bits long and we are on position 24, we take the 24-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0110100111001010100001010000000001100000011000101000001101101000
S=0110001000101111010001111

### Step 35

We find ourselves at position 25 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1110001000101111010001111.
As R is 64 bits long and we are on position 25, we take the 25-th bit of R, which is 0 and we compare it with the 0-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1100110001111110000100111101001000111010001010011110101001000101

### Step 36

We find ourselves at position 26 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0001110111010111010001111.
As R is 64 bits long and we are on position 26, we take the 26-th bit of R, which is 0 and we compare it with the 1-th bit of S, which is 0
Because they are equal we flip R's bit.
R=1100110001111110000100111111001000111010001010011110101001000101

### Step 37

We find ourselves at position 27 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1011011101111101111011010.
As R is 64 bits long and we are on position 27, we take the 27-th bit of R, which is 1 and we compare it with the 2-th bit of S, which is 1
Because they are equal we flip R's bit.
R=1100110001111110000100111110001000111010001010011110101001000101

### Step 38

We find ourselves at position 28 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0000000110100100110010011.
As R is 64 bits long and we are on position 28, we take the 28-th bit of R, which is 0 and we compare it with the 3-th bit of S, which is 0
Because they are equal we flip R's bit.
R=1100110001111110000100111110101000111010001010011110101001000101

### Step 39

We find ourselves at position 29 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 00000001101001001100100110
and we xor all its bits with the position-th elements of R. R thus becomes
R=0100100001011110010101001110011001111011001010111111001001100110
As R is 64 bits long and we are on position 29, we take the 29-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0100100001011110010101001110001001111011001010111111001001100110
S=11111110010110110011011001

### Step 40

We find ourselves at position 30 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 01010100111100011001110011.
As R is 64 bits long and we are on position 30, we take the 30-th bit of R, which is 1 and we compare it with the 4-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1110001011110100111111100100100011010001100000010101100011001100

### Step 41

We find ourselves at position 31 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010101001111000110011100110
and we xor all its bits with the position-th elements of R. R thus becomes
R=0110001010110101111011100000100011010011101000110111000011100110
As R is 64 bits long and we are on position 31, we take the 31-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0110001010110101111011100000100111010011101000110111000011100110

### Step 42

We find ourselves at position 31 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101010011110001100111001100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1110011011110100111111100100100111010001100000010101100011001100
As R is 64 bits long and we are on position 31, we take the 31-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1110011011110100111111100100100011010001100000010101100011001100
S=1010101100001110011000110011

### Step 43

We find ourselves at position 32 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10101011000011100110001100110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1110011011110100111111100100100001010001100000010101100011001100
As R is 64 bits long and we are on position 32, we take the 32-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1110011011110100111111100100100011010001100000010101100011001100

### Step 44

We find ourselves at position 32 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101010110000111001100011001100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1110011011110100111111100100100011010001100000010101100011001100
As R is 64 bits long and we are on position 32, we take the 32-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1110011011110100111111100100100001010001100000010101100011001100
S=010101001111000110011100110011

### Step 45

We find ourselves at position 33 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 010101001111000010111000010111.
As R is 64 bits long and we are on position 33, we take the 33-th bit of R, which is 1 and we compare it with the 3-th bit of S, which is 1
Because they are equal we flip R's bit.
R=1110011011110100111111100100100000010001100000010101100011001100

### Step 46

We find ourselves at position 34 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 111111100101101000010010111101.
As R is 64 bits long and we are on position 34, we take the 34-th bit of R, which is 0 and we compare it with the 4-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0100110001011110010101001110001010111011001010111111001001100110

### Step 47

We find ourselves at position 35 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 011110100111101000010010111101.
As R is 64 bits long and we are on position 35, we take the 35-th bit of R, which is 1 and we compare it with the 5-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1010111111010000011011000000000110100111010110100011010101111010

### Step 48

We find ourselves at position 36 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0111101001111010000100101111010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111101010000111001000000100100101111010110101011010111111010
As R is 64 bits long and we are on position 36, we take the 36-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1010111101010000111001000000100100100111010110101011010111111010
S=1000010110000101111011010000101

### Step 49

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000110101110100111011010000111100100010010110011101010101100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1000110101110100111011010000111100100110010110011101010101100011

### Step 50

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111101010000111001000000100110100011010110101011010111111010
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111101010000111001000000100110100111010110101011010111111010

### Step 51

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000100101110100111011010000111100100010010110011101010101100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1000100101110100111011010000111100100110010110011101010101100011

### Step 52

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111101010000111001000000100110100011011110101011010111111010
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111101010000111001000000100110100111011110101011010111111010

### Step 53

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000100101110101111011010000111100100010010110011101010101100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1000100101110101111011010000111100100110010110011101010101100011

### Step 54

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111101010000111001000000100110100011011110101011110111111010
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111101010000111001000000100110100111011110101011110111111010

### Step 55

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000100101110101111011010100111100100010010110011101010101100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1000100101110101111011010100111100100110010110011101010101100011

### Step 56

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111101010000111001000000100110100011011110101011110111111000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111101010000111001000000100110100111011110101011110111111000

### Step 57

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000100101110101111011010100111100110010010110011101010101100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1000100101110101111011010100111100110110010110011101010101100011

### Step 58

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111111010000111001000000100110100011011110101011110111111000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111111010000111001000000100110100111011110101011110111111000

### Step 59

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000100101110101111011010100111100110010010111011101010101100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1000100101110101111011010100111100110110010111011101010101100011

### Step 60

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111111010000110001000000100110100011011110101011110111111000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111111010000110001000000100110100111011110101011110111111000

### Step 61

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000100101110101111011010100111100110010010111011101010001100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1000100101110101111011010100111100110110010111011101010001100011

### Step 62

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111111010000110001000000000110100011011110101011110111111000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111111010000110001000000000110100111011110101011110111111000

### Step 63

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100101110101111011010100111100110010010111011101010001100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100101110101111011010100111100110110010111011101010001100011

### Step 64

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111111010000110001000000000110100001011110101011110111111000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111111010000110001000000000110100101011110101011110111111000

### Step 65

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100101100101111011010100111100110010010111011101010001100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100101100101111011010100111100110110010111011101010001100011

### Step 66

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111111010000110001000000000110100001011110100011110111111000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111111010000110001000000000110100101011110100011110111111000

### Step 67

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100101100101111010010100111100110010010111011101010001100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100101100101111010010100111100110110010111011101010001100011

### Step 68

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111111010000110001000000000110100001011110100011110111011000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111111010000110001000000000110100101011110100011110111011000

### Step 69

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100101100101111010010100111000110010010111011101010001100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100101100101111010010100111000110110010111011101010001100011

### Step 70

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010011111010000110001000000000110100001011110100011110111011000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010011111010000110001000000000110100101011110100011110111011000

### Step 71

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100101100101111010010100111000110010000111011101010001100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100101100101111010010100111000110110000111011101010001100011

### Step 72

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010011111010010110001000000000110100001011110100011110111011000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010011111010010110001000000000110100101011110100011110111011000

### Step 73

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100101100101111010010100111000110010000111011100010001100011
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100101100101111010010100111000110110000111011100010001100011

### Step 74

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010011111010010110001001000000110100001011110100011110111011000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010011111010010110001001000000110100101011110100011110111011000

### Step 75

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100101100101111010010100111000110010000111011100010001100111
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100101100101111010010100111000110110000111011100010001100111

### Step 76

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010011111010010110001001000000110000001011110100011110111011000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010011111010010110001001000000110000101011110100011110111011000

### Step 77

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100001100101111010010100111000110010000111011100010001100111
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100001100101111010010100111000110110000111011100010001100111

### Step 78

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010011111010010110001001000000110000001011100100011110111011000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010011111010010110001001000000110000101011100100011110111011000

### Step 79

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100001100101101010010100111000110010000111011100010001100111
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100001100101101010010100111000110110000111011100010001100111

### Step 80

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010011111010010110001001000000110000001011100100011111111011000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010011111010010110001001000000110000101011100100011111111011000

### Step 81

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000010110000101111011010000101000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100001100101101010010101111000110010000111011100010001100111
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100100001100101101010010101111000110110000111011100010001100111

### Step 82

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10000101100001011110110100001010000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010011111010010110001001000000110000001011100100011111111011000
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010011111010010110001001000000110000101011100100011111111011000

### Step 83

We find ourselves at position 37 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100001011000010111101101000010100000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100100001100101101010010101111000110110000111011100010001100111
As R is 64 bits long and we are on position 37, we take the 37-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1100100001100101101010010101111000110010000111011100010001100111
S=011110100111101000010010111101011111111111111111111111111111111111

### Step 84

We find ourselves at position 38 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0111101001111010000100101111010111111111111111111111111111111111110
and we xor all its bits with the position-th elements of R. R thus becomes
R=0100101001001101101010010101110010110010101101110100110011000101
As R is 64 bits long and we are on position 38, we take the 38-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0100101001001101101010010101110010110000101101110100110011000101
S=1000010110000101111011010000101000000000000000000000000000000000001

### Step 85

We find ourselves at position 39 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0001100111110110011000110011101111000111001110001110001100011100010.
As R is 64 bits long and we are on position 39, we take the 39-th bit of R, which is 0 and we compare it with the 39-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1001000000000110110000000111000110010101000000111101101000010111

### Step 86

We find ourselves at position 40 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1001100000001010011001001101101111111000101110010001111100011011101.
As R is 64 bits long and we are on position 40, we take the 40-th bit of R, which is 0 and we compare it with the 40-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1001000000000110110000000111000110010101000000111101101000010111

### Step 87

We find ourselves at position 41 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0101010011000111111111010100100011001011110111110111101111010111011.
As R is 64 bits long and we are on position 41, we take the 41-th bit of R, which is 0 and we compare it with the 41-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0100001010010000011101001101010010111000011010101001000101001101

### Step 88

We find ourselves at position 42 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1010110010111111100001010111010011110111111000010110010111001001011.
As R is 64 bits long and we are on position 42, we take the 42-th bit of R, which is 1 and we compare it with the 42-th bit of S, which is 1
Because they are equal we flip R's bit.
R=0100001010010000011101001101010010111000010010101001000101001101

### Step 89

We find ourselves at position 43 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10101100101111111000010101110100111101111110000101100101110010010110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000000111001100101001100110010110000001111101111110100100110
As R is 64 bits long and we are on position 43, we take the 43-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1111000000111001100101001100110010110000001011101111110100100110
S=01010011010000000111101010001011000010000001111010011010001101101001

### Step 90

We find ourselves at position 44 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 01010011010000000111101010001011000010000001111010011010001101101001.
As R is 64 bits long and we are on position 44, we take the 44-th bit of R, which is 1 and we compare it with the 44-th bit of S, which is 1
Because they are equal we flip R's bit.
R=1111000000111001100101001100110010110000001001101111110100100110

### Step 91

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010
and we xor all its bits with the position-th elements of R. R thus becomes
R=0000010011000101011001000001000001000101101100011011101100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0000010011000101011001000001000001000101101101011011101100000111

### Step 92

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000000111001100101001100110011110000001000101111110100100110
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000000111001100101001100110011110000001001101111110100100110

### Step 93

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0000010011000111011001000001000001000101101100011011101100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0000010011000111011001000001000001000101101101011011101100000111

### Step 94

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000000111001100101001100110011110000001000101111110100110110
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000000111001100101001100110011110000001001101111110100110110

### Step 95

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0000010011000111011001000001000001000101001100011011101100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0000010011000111011001000001000001000101001101011011101100000111

### Step 96

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000000111001100100001100110011110000001000101111110100110110
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000000111001100100001100110011110000001001101111110100110110

### Step 97

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010010011000111011001000001000001000101001100011011101100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010010011000111011001000001000001000101001101011011101100000111

### Step 98

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000000111001100100001100110011110000001000111111110100110110
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000000111001100100001100110011110000001001111111110100110110

### Step 99

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010010011000111011001000001100001000101001100011011101100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010010011000111011001000001100001000101001101011011101100000111

### Step 100

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001111001100100001100110011110000001000111111110100110110
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001111001100100001100110011110000001001111111110100110110

### Step 101

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010010011000111011001000001100001000101001100011011100100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010010011000111011001000001100001000101001101011011100100000111

### Step 102

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001111001100100001100110011100000001000111111110100110110
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001111001100100001100110011100000001001111111110100110110

### Step 103

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010010011000111111001000001100001000101001100011011100100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010010011000111111001000001100001000101001101011011100100000111

### Step 104

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001111001100100001100110011100000001000111111110100110010
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001111001100100001100110011100000001001111111110100110010

### Step 105

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010010011000111111001000001100001000101000100011011100100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010010011000111111001000001100001000101000101011011100100000111

### Step 106

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001111001100100011100110011100000001000111111110100110010
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001111001100100011100110011100000001001111111110100110010

### Step 107

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010110011000111111001000001100001000101000100011011100100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010110011000111111001000001100001000101000101011011100100000111

### Step 108

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001111001100100011100110011100000001000111011110100110010
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001111001100100011100110011100000001001111011110100110010

### Step 109

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010110011000111111001000001101001000101000100011011100100000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010110011000111111001000001101001000101000101011011100100000111

### Step 110

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001101001100100011100110011100000001000111011110100110010
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001101001100100011100110011100000001001111011110100110010

### Step 111

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010110011000111111001000001101001000101000100011011100110000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010110011000111111001000001101001000101000101011011100110000111

### Step 112

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001101001100100011100110011100100001000111011110100110010
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001101001100100011100110011100100001001111011110100110010

### Step 113

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010110011000111110001000001101001000101000100011011100110000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010110011000111110001000001101001000101000101011011100110000111

### Step 114

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001101001100100011100110011100100001000111011110100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001101001100100011100110011100100001001111011110100110011

### Step 115

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010110011000111110001000001101001000101000110011011100110000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010110011000111110001000001101001000101000111011011100110000111

### Step 116

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001101001100100011000110011100100001000111011110100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001101001100100011000110011100100001001111011110100110011

### Step 117

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111011000111110001000001101001000101000110011011100110000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111011000111110001000001101001000101000111011011100110000111

### Step 118

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001101001100100011000110011100100001000111010110100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001101001100100011000110011100100001001111010110100110011

### Step 119

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111011000111110001000001101011000101000110011011100110000111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111011000111110001000001101011000101000111011011100110000111

### Step 120

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001101101100100011000110011100100001000111010110100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001101101100100011000110011100100001001111010110100110011

### Step 121

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111011000111110001000001101011000101000110011011100110100111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111011000111110001000001101011000101000111011011100110100111

### Step 122

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111000001101101100100011000110011100101001000111010110100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111000001101101100100011000110011100101001001111010110100110011

### Step 123

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111011000111110011000001101011000101000110011011100110100111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111011000111110011000001101011000101000111011011100110100111

### Step 124

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011000001101101100100011000110011100101001000111010110100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1011000001101101100100011000110011100101001001111010110100110011

### Step 125

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111011000111110011000001101011000101000110111011100110100111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111011000111110011000001101011000101000111111011100110100111

### Step 126

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011000001101101100100011001110011100101001000111010110100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1011000001101101100100011001110011100101001001111010110100110011

### Step 127

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001000111110011000001101011000101000110111011100110100111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001000111110011000001101011000101000111111011100110100111

### Step 128

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011000001101101100100011001110011100101001000111010100100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1011000001101101100100011001110011100101001001111010100100110011

### Step 129

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001000111110011000001101011100101000110111011100110100111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001000111110011000001101011100101000111111011100110100111

### Step 130

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011000001101100100100011001110011100101001000111010100100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1011000001101100100100011001110011100101001001111010100100110011

### Step 131

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001000111110011000001101011100101000110111011100110101111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001000111110011000001101011100101000111111011100110101111

### Step 132

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011000001101100100100011001110011100101011000111010100100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1011000001101100100100011001110011100101011001111010100100110011

### Step 133

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001000111110011100001101011100101000110111011100110101111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001000111110011100001101011100101000111111011100110101111

### Step 134

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000001101100100100011001110011100101011000111010100100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000001101100100100011001110011100101011001111010100100110011

### Step 135

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001000111110011100001101011100101000110110011100110101111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001000111110011100001101011100101000111110011100110101111

### Step 136

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000001101100100100011001100011100101011000111010100100110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000001101100100100011001100011100101011001111010100100110011

### Step 137

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001100111110011100001101011100101000110110011100110101111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001100111110011100001101011100101000111110011100110101111

### Step 138

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000001101100100100011001100011100101011000111010100000110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000001101100100100011001100011100101011001111010100000110011

### Step 139

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001100111110011100001101011101101000110110011100110101111
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001100111110011100001101011101101000111110011100110101111

### Step 140

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000001101100110100011001100011100101011000111010100000110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000001101100110100011001100011100101011001111010100000110011

### Step 141

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001100111110011100001101011101101000110110011100110101101
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001100111110011100001101011101101000111110011100110101101

### Step 142

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000001101100110100011001100011100101011100111010100000110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000001101100110100011001100011100101011101111010100000110011

### Step 143

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001100111110011101001101011101101000110110011100110101101
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001100111110011101001101011101101000111110011100110101101

### Step 144

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010010001101100110100011001100011100101011100111010100000110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010010001101100110100011001100011100101011101111010100000110011

### Step 145

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001100111110011101001101011101101000110110001100110101101
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001100111110011101001101011101101000111110001100110101101

### Step 146

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010010001101100110100011001100111100101011100111010100000110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010010001101100110100011001100111100101011101111010100000110011

### Step 147

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001101111110011101001101011101101000110110001100110101101
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001101111110011101001101011101101000111110001100110101101

### Step 148

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010010001101100110100011001100111100101011100111010100001110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010010001101100110100011001100111100101011101111010100001110011

### Step 149

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010111001101111110011101001101011101111000110110001100110101101
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0010111001101111110011101001101011101111000111110001100110101101

### Step 150

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01010011010000000111101010001011000010000001111010011010001101101001000000000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010010001101100110000011001100111100101011100111010100001110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010010001101100110000011001100111100101011101111010100001110011

### Step 151

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010100110100000001111010100010110000100000011110100110100011011010010000000000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010111001101111110011101001101011101111000110110001100110101101
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010111001101111110011101001101011101111000111110001100110101101

### Step 152

We find ourselves at position 45 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101001101000000011110101000101100001000000111101001101000110110100100000000000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010010001101100110000011001100111100101011101111010100001110011
As R is 64 bits long and we are on position 45, we take the 45-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1010010001101100110000011001100111100101011100111010100001110011
S=1010110010111111100001010111010011110111111000010110010111001001011011111111111111111111111111111111111111111111111111111111111111

### Step 153

We find ourselves at position 46 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0000011000010101001011111101111001011101010010111100111101100011110001010101010101010101010101010101010101010101010101010101010101.
As R is 64 bits long and we are on position 46, we take the 46-th bit of R, which is 1 and we compare it with the 46-th bit of S, which is 1
Because they are equal we flip R's bit.
R=1010010001101100110000011001100111100101011100011010100001110011

### Step 154

We find ourselves at position 47 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1010001110100001100110010100110010001111000100001000010000001010111010000111000011110001111000111100001110000111000011110001111000.
As R is 64 bits long and we are on position 47, we take the 47-th bit of R, which is 1 and we compare it with the 47-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0100001000001010111100101010101011111100111010000110010010111111

### Step 155

We find ourselves at position 48 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0000100100001011001100111110011000100101101110100010111010100000010000101101101001011011010010010110100100101101101001011011010010.
As R is 64 bits long and we are on position 48, we take the 48-th bit of R, which is 0 and we compare it with the 48-th bit of S, which is 0
Because they are equal we flip R's bit.
R=0100001000001010111100101010101011111100111010001110010010111111

### Step 156

We find ourselves at position 49 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1010001110100001111001101011001100001111000100001111101111110101011010000111000011001110000111000000001110000111001100001110000111.
As R is 64 bits long and we are on position 49, we take the 49-th bit of R, which is 1 and we compare it with the 49-th bit of S, which is 1
Because they are equal we flip R's bit.
R=0100001000001010111100101010101011111100111010001010010010111111

### Step 157

We find ourselves at position 50 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 0010001110000001111011101011000100001111100100001101101111111101011010100111000001001110001111000000101110000101001100000110000111.
As R is 64 bits long and we are on position 50, we take the 50-th bit of R, which is 1 and we compare it with the 50-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1110100010100000010110000000000001010110010000100000111000010101

### Step 158

We find ourselves at position 51 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 00100011100000011110111010110001000011111001000011011011111111010110101001110000010011100011110000001011100001010011000001100001110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1001100100111000100100101000110101010001110001101101000100010011
As R is 64 bits long and we are on position 51, we take the 51-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1001100100111000100100101000110101010001110001101100000100010011
S=11011100011111100001000101001110111100000110111100100100000000101001010110001111101100011100001111110100011110101100111110011110001

### Step 159

We find ourselves at position 52 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 110111000111111000010001010011101111000001101111001001000000001010010101100011111011000111000011111101000111101011001111100111100010
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001000110110000100110101000010111011001110001101100100110011011
As R is 64 bits long and we are on position 52, we take the 52-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0001000110110000100110101000010111011001110001101100000110011011
S=001000111000000111101110101100010000111110010000110110111111110101101010011100000100111000111100000010111000010100110000011000011101

### Step 160

We find ourselves at position 53 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 110111000111110111101110101011101111000010010000110111000000001010101010011100001011000111000100000010111011101011001110011000011101.
As R is 64 bits long and we are on position 53, we take the 53-th bit of R, which is 0 and we compare it with the 53-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1100010011111010001100111101000011110011011100111001011100110001

### Step 161

We find ourselves at position 54 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 010111100111010111001110001011001111100010110000010111100000101010001010111100101011100111100100100010011011001011101110111000111101.
As R is 64 bits long and we are on position 54, we take the 54-th bit of R, which is 1 and we compare it with the 54-th bit of S, which is 1
Because they are equal we flip R's bit.
R=1100010011111010001100111101000011110011011100111001010100110001

### Step 162

We find ourselves at position 55 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 010111100111010111001100001011001111100010111000010111100000101010101010111101101011100111100100100110011011001011101110101000111101.
As R is 64 bits long and we are on position 55, we take the 55-th bit of R, which is 1 and we compare it with the 55-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0011110011000110001011011101111111110100101100000111010011000001

### Step 163

We find ourselves at position 56 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101111001110101110011000010110011111000101110000101111000001010101010101111011010111001111001001001100110110010111011101010001111010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011110011000110001011011101111111110100001100000111010011000001
As R is 64 bits long and we are on position 56, we take the 56-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1011110011000110001011011101111111110100001100000111010001000001
S=1010000110001010001100111101001100000111010001111010000111110101010101010000100101000110000110110110011001001101000100010101110000101

### Step 164

We find ourselves at position 57 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100010100011001111010011000001110100011110100001111101010101010100001001010001100001101101100110010011010001000101011100001010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1001110100001110010011000000010011010100000101011101010011011011
As R is 64 bits long and we are on position 57, we take the 57-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1001110100001110010011000000010011010100000101011101010010011011
S=01011110011101011100110000101100111110001011100001011110000010101010101011110110101110011110010010011001101100101110111010100011110101

### Step 165

We find ourselves at position 58 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010111100111010111001100001011001111100010111000010111100000101010101010111101101011100111100100100110011011001011101110101000111101010
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011111100001110110011100010110001111110101101111101111000011011
As R is 64 bits long and we are on position 58, we take the 58-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011111100001110110011100010110001111110101101111101111000111011

### Step 166

We find ourselves at position 58 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101111001110101110011000010110011111000101110000101111000001010101010101111011010111001111001001001100110110010111011101010001111010100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1001110100001110010011100000010011010100000101011101010010111011
As R is 64 bits long and we are on position 58, we take the 58-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1001110100001110010011100000010011010100000101011101010010011011
S=1010000110001010001100111101001100000111010001111010000111110101010101010000100101000110000110110110011001001101000100010101110000101011

### Step 167

We find ourselves at position 59 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100010100011001111010011000001110100011110100001111101010101010100001001010001100001101101100110010011010001000101011100001010110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101110001010110001010011011010011110100001011101101010111111
As R is 64 bits long and we are on position 59, we take the 59-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1100101110001010110001010011011010011110100001011101101010101111
S=01011110011101011100110000101100111110001011100001011110000010101010101011110110101110011110010010011001101100101110111010100011110101001

### Step 168

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010111100111010111001100001011001111100010111000010111100000101010101010111101101011100111100100100110011011001011101110101000111101010010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101110001010010001011011011000010110000001010101001000100111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100101110001010010001011011011000010110000001010101001000101111

### Step 169

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101111001110101110011000010110011111000101110000101111000001010101010101111011010111001111001001001100110110010111011101010001111010100100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101110001010110001011011011010011110100001011101101010100111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100101110001010110001011011011010011110100001011101101010101111

### Step 170

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01011110011101011100110000101100111110001011100001011110000010101010101011110110101110011110010010011001101100101110111010100011110101001000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101110001010010011011011011000010110000001010101001000100111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100101110001010010011011011011000010110000001010101001000101111

### Step 171

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010111100111010111001100001011001111100010111000010111100000101010101010111101101011100111100100100110011011001011101110101000111101010010000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101110001010010001011011011010011110100001011101101010100111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100101110001010010001011011011010011110100001011101101010101111

### Step 172

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101111001110101110011000010110011111000101110000101111000001010101010101111011010111001111001001001100110110010111011101010001111010100100000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101110000010010011011011011000010110000001010101001000100111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100101110000010010011011011011000010110000001010101001000101111

### Step 173

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01011110011101011100110000101100111110001011100001011110000010101010101011110110101110011110010010011001101100101110111010100011110101001000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100101100001010010001011011011010011110100001011101101010100111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100101100001010010001011011011010011110100001011101101010101111

### Step 174

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010111100111010111001100001011001111100010111000010111100000101010101010111101101011100111100100100110011011001011101110101000111101010010000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100001110000010010011011011011000010110000001010101001000100111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1100001110000010010011011011011000010110000001010101001000101111

### Step 175

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 0101111001110101110011000010110011111000101110000101111000001010101010101111011010111001111001001001100110110010111011101010001111010100100000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0100101100001010010001011011011010011110100001011101101010100111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0100101100001010010001011011011010011110100001011101101010101111

### Step 176

We find ourselves at position 60 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01011110011101011100110000101100111110001011100001011110000010101010101011110110101110011110010010011001101100101110111010100011110101001000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100001110000010010011011011011000010110000001010101001000101111
As R is 64 bits long and we are on position 60, we take the 60-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1100001110000010010011011011011000010110000001010101001000100111
S=10100001100010100011001111010011000001110100011110100001111101010101010100001001010001100001101101100110010011010001000101011100001010110111111111

### Step 177

We find ourselves at position 61 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 00001011001001110110011011111001101010100001001010001011010110000000000000100011111011110100111000001100111001000100010000110110100000100010101010.
As R is 64 bits long and we are on position 61, we take the 61-th bit of R, which is 1 and we compare it with the 61-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0000101010100110110111111111111100100000110111100011111110010001

### Step 178

We find ourselves at position 62 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000.
As R is 64 bits long and we are on position 62, we take the 62-th bit of R, which is 0 and we compare it with the 62-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1010000000001100011101010101010110001010011101001001010100111011

### Step 179

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110011101111100101111111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110011101111100101111111111101000100111

### Step 180

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101010110001010011100001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101010110001010011100001001010100111011

### Step 181

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110011101111100101101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110011101111100101101111111101000100111

### Step 182

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101010110001010011000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101010110001010011000001001010100111011

### Step 183

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110011101111100100101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110011101111100100101111111101000100111

### Step 184

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101010110001010001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101010110001010001000001001010100111011

### Step 185

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110011101111100000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110011101111100000101111111101000100111

### Step 186

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101010110001011001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101010110001011001000001001010100111011

### Step 187

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110011101111110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110011101111110000101111111101000100111

### Step 188

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101010110001111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101010110001111001000001001010100111011

### Step 189

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110011101110110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110011101110110000101111111101000100111

### Step 190

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101010110011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101010110011111001000001001010100111011

### Step 191

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110011101010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110011101010110000101111111101000100111

### Step 192

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101010111011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101010111011111001000001001010100111011

### Step 193

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110011111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110011111010110000101111111101000100111

### Step 194

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101010011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101010011011111001000001001010100111011

### Step 195

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110010111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110010111010110000101111111101000100111

### Step 196

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010101000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010101000011011111001000001001010100111011

### Step 197

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101110110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101110110111010110000101111111101000100111

### Step 198

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010100000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010100000011011111001000001001010100111011

### Step 199

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000101100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000101100110111010110000101111111101000100111

### Step 200

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101010000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101010000000011011111001000001001010100111011

### Step 201

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000100100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000100100110111010110000101111111101000100111

### Step 202

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011101000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011101000000000011011111001000001001010100111011

### Step 203

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110000000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110000000100110111010110000101111111101000100111

### Step 204

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011100000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011100000000000011011111001000001001010100111011

### Step 205

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101110010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101110010000100110111010110000101111111101000100111

### Step 206

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100011000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100011000000000000011011111001000001001010100111011

### Step 207

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101111010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101111010000100110111010110000101111111101000100111

### Step 208

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001100001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001100001000000000000011011111001000001001010100111011

### Step 209

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110101011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110101011010000100110111010110000101111111101000100111

### Step 210

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001101001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001101001000000000000011011111001000001001010100111011

### Step 211

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101110111011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101110111011010000100110111010110000101111111101000100111

### Step 212

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000001001001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000001001001000000000000011011111001000001001010100111011

### Step 213

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101111111011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101111111011010000100110111010110000101111111101000100111

### Step 214

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000000011001001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000000011001001000000000000011011111001000001001010100111011

### Step 215

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101101011111011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101101011111011010000100110111010110000101111111101000100111

### Step 216

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000001011001001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000001011001001000000000000011011111001000001001010100111011

### Step 217

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001101111011111011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001101111011111011010000100110111010110000101111111101000100111

### Step 218

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010000101011001001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010000101011001001000000000000011011111001000001001010100111011

### Step 219

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001100111011111011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001100111011111011010000100110111010110000101111111101000100111

### Step 220

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010010101011001001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1010010101011001001000000000000011011111001000001001010100111011

### Step 221

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001000111011111011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001000111011111011010000100110111010110000101111111101000100111

### Step 222

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011010101011001001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1011010101011001001000000000000011011111001000001001010100111011

### Step 223

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011000111011111011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011000111011111011010000100110111010110000101111111101000100111

### Step 224

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111010101011001001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1111010101011001001000000000000011011111001000001001010100111011

### Step 225

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011000111011111011010000100110111010110000101111111101000100110
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1011000111011111011010000100110111010110000101111111101000100111

### Step 226

We find ourselves at position 63 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111010101011001001000000000000011011111001000001001010100111011
As R is 64 bits long and we are on position 63, we take the 63-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1111010101011001001000000000000011011111001000001001010100111010
S=01011110011100100011001110101100111111110100011111011110000011010101010101110110101110100001101101011001101100010001000101100011110101110111111111111111111111111111111111111111111111111111111111

### Step 227

We find ourselves at position 64 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 010111100111001000110011101011001111111101000111110111100000110101010101011101101011101000011011010110011011000100010001011000111101011101111111111111111111111111111111111111111111111111111111110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1111010101011001001000000000000011011111001000001001010100111010
As R is 64 bits long and we are on position 64, we take the 0-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0111010101011001001000000000000011011111001000001001010100111010
S=101000011000110111001100010100110000000010111000001000011111001010101010100010010100010111100100101001100100111011101110100111000010100010000000000000000000000000000000000000000000000000000000001

### Step 228

We find ourselves at position 65 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1010000110001101110011000101001100000000101110000010000111110010101010101000100101000101111001001010011001001110111011101001110000101000100000000000000000000000000000000000000000000000000000000010
and we xor all its bits with the position-th elements of R. R thus becomes
R=0111100100100010010101100100100010000110001010011010010110101011
As R is 64 bits long and we are on position 65, we take the 1-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0011100100100010010101100100100010000110001010011010010110101011
S=0101111001110010001100111010110011111111010001111101111000001101010101010111011010111010000110110101100110110001000100010110001111010111011111111111111111111111111111111111111111111111111111111101

### Step 229

We find ourselves at position 66 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01011110011100100011001110101100111111110100011111011110000011010101010101110110101110100001101101011001101100010001000101100011110101110111111111111111111111111111111111111111111111111111111111010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1011000110000000011111000100000010100110000000010000011100101001
As R is 64 bits long and we are on position 66, we take the 2-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1001000110000000011111000100000010100110000000010000011100101001
S=10100001100011011100110001010011000000001011100000100001111100101010101010001001010001011110010010100110010011101110111010011100001010001000000000000000000000000000000000000000000000000000000000101

### Step 230

We find ourselves at position 67 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 01101101010000010000000010011111110011000111010011101101001111100111001100010000110111000111110100111111110101110111011100000101101110111011001100110011001100110011001100110011001100110011001100011.
As R is 64 bits long and we are on position 67, we take the 3-th bit of R, which is 1 and we compare it with the 67-th bit of S, which is 1
Because they are equal we flip R's bit.
R=1000000110000000011111000100000010100110000000010000011100101001

### Step 231

We find ourselves at position 68 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 11000110000101111010110111000101010110010101111010111001100101110010100110100101101101101010100010010110100001011101001001001111001011100001100001100101100111100110100110100110000110010110011110110.
As R is 64 bits long and we are on position 68, we take the 4-th bit of R, which is 0 and we compare it with the 68-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1000000110000000011111000100000010100110000000010000011100101001

### Step 232

We find ourselves at position 69 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 00111110001010011010001001000110101110011010011010000111100110001010111001100100010001101101010010001001100000100001001110111111010101100010011001101010000111011000100101011110001001110110100000110.
As R is 64 bits long and we are on position 69, we take the 5-th bit of R, which is 0 and we compare it with the 69-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0110011010111001101100100011001110111110110001110011011010100101

### Step 233

We find ourselves at position 70 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 11101100111111110011010011110010000111000000001110101010101100011100010100101111000111001000111001011011000101001000011100001011111100111000101101000111011101001110001000010100011111010011101011100.
As R is 64 bits long and we are on position 70, we take the 6-th bit of R, which is 1 and we compare it with the 70-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1100110000010011000110001001100100010100011011011001110000001111

### Step 234

We find ourselves at position 71 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 111011001111111100110100111100100001110000000011101010101011000111000101001011110001110010001110010110110001010010000111000010111111001110001011010001110111010011100010000101000111110100111010111000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000101000100000101111100100011000011111111100000110001011110011
As R is 64 bits long and we are on position 71, we take the 7-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1000101100100000101111100100011000011111111100000110001011110011

### Step 235

We find ourselves at position 71 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1110110011111111001101001111001000011100000000111010101010110001110001010010111100011100100011100101101100010100100001110000101111110011100010110100011101110100111000100001010001111101001110101110000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100110100010011000110001001100100010100010011011001110000001111
As R is 64 bits long and we are on position 71, we take the 7-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1100110000010011000110001001100100010100010011011001110000001111
S=0001001100000000110010110000110111100011111111000101010101001110001110101101000011100011011100011010010011101011011110001111010000001100011101001011100010001011000111011110101110000010110001010001111

### Step 236

We find ourselves at position 72 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 00010011000000001100101100001101111000111111110001010101010011100011101011010000111000110111000110100100111010110111100011110100000011000111010010111000100010110001110111101011100000101100010100011110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1100110010010011100110000001100100010100010011011001110010001111
As R is 64 bits long and we are on position 72, we take the 8-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1100110000010011100110000001100100010100010011011001110010001111
S=11101100111111110011010011110010000111000000001110101010101100011100010100101111000111001000111001011011000101001000011100001011111100111000101101000111011101001110001000010100011111010011101011100001

### Step 237

We find ourselves at position 73 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 01011010001101100000001000101011001110101101101010001110011010101110000111110100011110000001010100111111100001111110101110011001100111100001100100101010110001101010111110100110001101001000110010101000.
As R is 64 bits long and we are on position 73, we take the 9-th bit of R, which is 0 and we compare it with the 73-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0100101111010000011110011110100101101100011100011000001010000000

### Step 238

We find ourselves at position 74 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 11110000100111001010100010000001100100000111000000100100110000000100101101011110110100101011111110010101001011010100000100110011001101001011001110000000011011000000010100001100100111100010011000000010.
As R is 64 bits long and we are on position 74, we take the 10-th bit of R, which is 0 and we compare it with the 74-th bit of S, which is 0
Because they are equal we flip R's bit.
R=0100101111110000011110011110100101101100011100011000001010000000

### Step 239

We find ourselves at position 75 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 01110000100111001010100011000001100100000111000000100100110000000100101101001110110100101011111110010101001011010100000100110011001101001011001110000010011011000000010100001100100111100010011000000010.
As R is 64 bits long and we are on position 75, we take the 11-th bit of R, which is 1 and we compare it with the 75-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1110000101000101001011110100001100111001001110110010101111010101

### Step 240

We find ourselves at position 76 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 01110000100111001010100011000001100100000111000000100100110000000100101101001110110100101011111110010101001011010100000100110011001101001011001110000010011011000000010100001100100111100010011000000010.
As R is 64 bits long and we are on position 76, we take the 12-th bit of R, which is 0 and we compare it with the 76-th bit of S, which is 1
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1110000101000101001011110100001100111001001110110010101111010101

### Step 241

We find ourselves at position 77 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010.
As R is 64 bits long and we are on position 77, we take the 13-th bit of R, which is 1 and we compare it with the 77-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0001111101000010110111110111110000111000110000110010010000010101

### Step 242

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001110111000000011101011101110000011000011000011000010010011101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001110111000010011101011101110000011000011000011000010010011101

### Step 243

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001111101000000110111110111110000111000110000110010010000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001111101000010110111110111110000111000110000110010010000010111

### Step 244

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001110111001000011101011101110000011000011000011000010010011101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001110111001010011101011101110000011000011000011000010010011101

### Step 245

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001111101000000110111110101110000111000110000110010010000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001111101000010110111110101110000111000110000110010010000010111

### Step 246

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001110111001000011101011101110000011000111000011000010010011101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001110111001010011101011101110000011000111000011000010010011101

### Step 247

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001111101000000110111110101110000111000110000110010011000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001111101000010110111110101110000111000110000110010011000010111

### Step 248

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010111001000011101011101110000011000111000011000010010011101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010111001010011101011101110000011000111000011000010010011101

### Step 249

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001111101000000111111110101110000111000110000110010011000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001111101000010111111110101110000111000110000110010011000010111

### Step 250

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010111001000011101011101110010011000111000011000010010011101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010111001010011101011101110010011000111000011000010010011101

### Step 251

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001111101000000111111110101110000111000110000010010011000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001111101000010111111110101110000111000110000010010011000010111

### Step 252

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010111001000011101011101110010011000111000011000010010010101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010111001010011101011101110010011000111000011000010010010101

### Step 253

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001111101100000111111110101110000111000110000010010011000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001111101100010111111110101110000111000110000010010011000010111

### Step 254

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010111001000011101010101110010011000111000011000010010010101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010111001010011101010101110010011000111000011000010010010101

### Step 255

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001111101100000111111110101110000111010110000010010011000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001111101100010111111110101110000111010110000010010011000010111

### Step 256

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010111001000011101010101110010011000111000011000110010010101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010111001010011101010101110010011000111000011000110010010101

### Step 257

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011111101100000111111110101110000111010110000010010011000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011111101100010111111110101110000111010110000010010011000010111

### Step 258

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010111001000111101010101110010011000111000011000110010010101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010111001010111101010101110010011000111000011000110010010101

### Step 259

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011111101100000111111110101111000111010110000010010011000010111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011111101100010111111110101111000111010110000010010011000010111

### Step 260

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010111001000111101010101110010011000111010011000110010010101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010111001010111101010101110010011000111010011000110010010101

### Step 261

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011111101100000111111110101111000111010110000010010011000110111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011111101100010111111110101111000111010110000010010011000110111

### Step 262

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010101001000111101010101110010011000111010011000110010010101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010101001010111101010101110010011000111010011000110010010101

### Step 263

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011111101100000111111010101111000111010110000010010011000110111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011111101100010111111010101111000111010110000010010011000110111

### Step 264

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001010101001000111101010101110010010000111010011000110010010101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0001010101001010111101010101110010010000111010011000110010010101

### Step 265

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011111101100000111111010101111000111010110000010000011000110111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0011111101100010111111010101111000111010110000010000011000110111

### Step 266

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 100011111001110001010111110000000110111001110001110110001100001110110111010010010010101010111000011001010010001010110001001111001101010010101100011000100101001111000101001100110001111001011001100000100000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1001010101001000111101010101110010010000111010011000110010010101
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1001010101001010111101010101110010010000111010011000110010010101

### Step 267

We find ourselves at position 78 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1000111110011100010101111100000001101110011100011101100011000011101101110100100100101010101110000110010100100010101100010011110011010100101011000110001001010011110001010011001100011110010110011000001000000000000000000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0011111101100010111111010101111000111010110000010000011000110111
As R is 64 bits long and we are on position 78, we take the 14-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0011111101100000111111010101111000111010110000010000011000110111
S=0111000001100011101010000011111110010001100011100010011100111100010010001011011011010101010001111001101011011101010011101100001100101011010100111001110110101100001110101100110011100001101001100111110111111111111111111111111111

### Step 268

We find ourselves at position 79 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 01110000011000111010100000111111100100011000111000100111001111000100100010110110110101010100011110011010110111010100111011000011001010110101001110011101101011000011101011001100111000011010011001111101111111111111111111111111110
and we xor all its bits with the position-th elements of R. R thus becomes
R=0001110011010001101011110010000111010101111110100000110001001001
As R is 64 bits long and we are on position 79, we take the 15-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0001110011010000101011110010000111010101111110100000110001001001
S=10001111100111000101011111000000011011100111000111011000110000111011011101001001001010101011100001100101001000101011000100111100110101001010110001100010010100111100010100110011000111100101100110000010000000000000000000000000001

### Step 269

We find ourselves at position 80 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 01011010110010101111110101110101001110110101101101110001100101101111110111100011111111111110111011001111100101111110010000010110011111011111100100101000111110010001000001100101101101001110110011010111001010101010100101010101011.
As R is 64 bits long and we are on position 80, we take the 16-th bit of R, which is 1 and we compare it with the 80-th bit of S, which is 1
Because they are equal we flip R's bit.
R=0001110011010000001011110010000111010101111110100000110001001001

### Step 270

We find ourselves at position 81 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 11011010101101010111110100001010101110110010010011110001111010010111110110011100001111111101000100001111101010000010010000101001101111011100011011101000111001101111000001111010010101001111001100110111001101010100100101001010100.
As R is 64 bits long and we are on position 81, we take the 17-th bit of R, which is 0 and we compare it with the 81-th bit of S, which is 0
Because they are equal we flip R's bit.
R=0001110011010000011011110010000111010101111110100000110001001001

### Step 271

We find ourselves at position 82 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 00101011011100100110001100110010010110001010001111101101100110011001111000010010000000111010000011001000001001100001110011001000011110101101101011010000000001010111111101100110001001010001000010111001000011010011100010001101100.
As R is 64 bits long and we are on position 82, we take the 18-th bit of R, which is 1 and we compare it with the 82-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=1011011001111010110001011000101101111111010100001010011011100011

### Step 272

We find ourselves at position 83 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 001010110111001001100011001100100101100010100011111011011001100110011110000100100000001110100000110010000010011000011100110010000111101011011010110100000000010101111111011001100010010100010000101110010000110100111000100011011000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101110101011000100110000010011000111101110100000101110110001001
As R is 64 bits long and we are on position 83, we take the 19-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1101110101011000100010000010011000111101110100000101110110001001
S=110101001000110110011100110011011010011101011100000100100110011001100001111011011111110001011111001101111101100111100011001101111000010100100101001011111111101010000000100110011101101011101111010001101111001011000111011100100111

### Step 273

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1101010010001101100111001100110110100111010111000001001001100110011000011110110111111100010111110011011111011001111000110011011110000101001001010010111111111010100000001001100111011010111011110100011011110010110001110111001001110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010101010000000000001010011000110101110110001101110110001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101010101010000000010001010011000110101110110001101110110001001

### Step 274

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 11010100100011011001110011001101101001110101110000010010011001100110000111101101111111000101111100110111110110011110001100110111100001010010010100101111111110101000000010011001110110101110111101000110111100101100011101110010011100
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101110101011000100000000010011000110101110100000101110110001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101110101011000100010000010011000110101110100000101110110001001

### Step 275

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 110101001000110110011100110011011010011101011100000100100110011001100001111011011111110001011111001101111101100111100011001101111000010100100101001011111111101010000000100110011101101011101111010001101111001011000111011100100111000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010101010000000000001010011000110101110110001101110100001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101010101010000000010001010011000110101110110001101110100001001

### Step 276

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1101010010001101100111001100110110100111010111000001001001100110011000011110110111111100010111110011011111011001111000110011011110000101001001010010111111111010100000001001100111011010111011110100011011110010110001110111001001110000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101110101010000100000000010011000110101110100000101110110001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101110101010000100010000010011000110101110100000101110110001001

### Step 277

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 11010100100011011001110011001101101001110101110000010010011001100110000111101101111111000101111100110111110110011110001100110111100001010010010100101111111110101000000010011001110110101110111101000110111100101100011101110010011100000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010101010000000000001010011010110101110110001101110100001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101010101010000000010001010011010110101110110001101110100001001

### Step 278

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 110101001000110110011100110011011010011101011100000100100110011001100001111011011111110001011111001101111101100111100011001101111000010100100101001011111111101010000000100110011101101011101111010001101111001011000111011100100111000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101110101010000100000000010011000110101110100000101010110001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101110101010000100010000010011000110101110100000101010110001001

### Step 279

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1101010010001101100111001100110110100111010111000001001001100110011000011110110111111100010111110011011111011001111000110011011110000101001001010010111111111010100000001001100111011010111011110100011011110010110001110111001001110000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010111010000000000001010011010110101110110001101110100001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101010111010000000010001010011010110101110110001101110100001001

### Step 280

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 11010100100011011001110011001101101001110101110000010010011001100110000111101101111111000101111100110111110110011110001100110111100001010010010100101111111110101000000010011001110110101110111101000110111100101100011101110010011100000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101110101010000100000000010111000110101110100000101010110001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101110101010000100010000010111000110101110100000101010110001001

### Step 281

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 110101001000110110011100110011011010011101011100000100100110011001100001111011011111110001011111001101111101100111100011001101111000010100100101001011111111101010000000100110011101101011101111010001101111001011000111011100100111000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010111010000000000001010011010110101110110000101110100001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101010111010000000010001010011010110101110110000101110100001001

### Step 282

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1101010010001101100111001100110110100111010111000001001001100110011000011110110111111100010111110011011111011001111000110011011110000101001001010010111111111010100000001001100111011010111011110100011011110010110001110111001001110000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010101010000100000000010111000110101110100000101010110001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101010101010000100010000010111000110101110100000101010110001001

### Step 283

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 11010100100011011001110011001101101001110101110000010010011001100110000111101101111111000101111100110111110110011110001100110111100001010010010100101111111110101000000010011001110110101110111101000110111100101100011101110010011100000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010111010000000000000010011010110101110110000101110100001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101010111010000000010000010011010110101110110000101110100001001

### Step 284

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 110101001000110110011100110011011010011101011100000100100110011001100001111011011111110001011111001101111101100111100011001101111000010100100101001011111111101010000000100110011101101011101111010001101111001011000111011100100111000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010101010000100000000010111000110101110110000101010110001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 1101010101010000100010000010111000110101110110000101010110001001

### Step 285

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1101010010001101100111001100110110100111010111000001001001100110011000011110110111111100010111110011011111011001111000110011011110000101001001010010111111111010100000001001100111011010111011110100011011110010110001110111001001110000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=0101010111010000000000000010011010110101110110000101110100001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 0
Because the R bit is 0, we flip it and decrease our position by 1 (but not below 0)
R= 0101010111010000000010000010011010110101110110000101110100001001

### Step 286

We find ourselves at position 84 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 11010100100011011001110011001101101001110101110000010010011001100110000111101101111111000101111100110111110110011110001100110111100001010010010100101111111110101000000010011001110110101110111101000110111100101100011101110010011100000000000000
and we xor all its bits with the position-th elements of R. R thus becomes
R=1101010101010000100010000010111000110101110110000101010110001001
As R is 64 bits long and we are on position 84, we take the 20-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1101010101010000100000000010111000110101110110000101010110001001
S=00101011011100100110001100110010010110001010001111101101100110011001111000010010000000111010000011001000001001100001110011001000011110101101101011010000000001010111111101100110001001010001000010111001000011010011100010001101100011111111111111

### Step 287

We find ourselves at position 85 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 001010110111001001100011001100100101100010100011111011011001100110011110000100100000001110100000110010000010011000011100110010000111101011011010110100000000010101111111011001100010010100010000101110010000110100111000100011011000111111111111110
and we xor all its bits with the position-th elements of R. R thus becomes
R=1010110001111000011001111010011000111110001100100001001010011010
As R is 64 bits long and we are on position 85, we take the 21-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1010110001111000011000111010011000111110001100100001001010011010
S=110101001000110110011100110011011010011101011100000100100110011001100001111011011111110001011111001101111101100111100011001101111000010100100101001011111111101010000000100110011101101011101111010001101111001011000111011100100111000000000000001

### Step 288

We find ourselves at position 86 in M, that bit is 0.
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 1101010010001101100111001100110110100111010111000001001001100110011000011110110111111100010111110011011111011001111000110011011110000101001001010010111111111010100000001001100111011010111011110100011011110010110001110111001001110000000000000010
and we xor all its bits with the position-th elements of R. R thus becomes
R=1000010011011010010010111010111010111100100100001001101000011010
As R is 64 bits long and we are on position 86, we take the 22-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 1000010011011010010010011010111010111100100100001001101000011010
S=0010101101110010011000110011001001011000101000111110110110011001100111100001001000000011101000001100100000100110000111001100100001111010110110101101000000000101011111110110011000100101000100001011100100001101001110001000110110001111111111111101

### Step 289

We find ourselves at position 87 in M, that bit is 1.
Because the bit is 1, we flip the M%S-th, 2M%S-th, ... nM%S-th bits in S, where n = len(S)/2.
S = 1111111000100111000010011001100011101101111101101011111100110011001101110100011101010110000010100110001011110011010010011000001011010000011111111000010101010111110101011100110101110000010001010001001110100111101011011101100011000101010101010111.
As R is 64 bits long and we are on position 87, we take the 23-th bit of R, which is 1 and we compare it with the 87-th bit of S, which is 0
Because they don't match we flip the M%S-th, 2M%S-th, ... nM%S-th bits in R. R becomes
R=0010100110110011000000101111010011101110000001100010111010111111

### Step 290

We find ourselves at position 88 in M, that bit is .
Because the bit is 0, we add a null bit to the state machine, which now becomes
S = 11111110001001110000100110011000111011011111011010111111001100110011011101000111010101100000101001100010111100110100100110000010110100000111111110000101010101111101010111001101011100000100010100010011101001111010110111011000110001010101010101110
and we xor all its bits with the position-th elements of R. R thus becomes
R=0010100110110011000000101111010011101110000001101010111010111111
As R is 64 bits long and we are on position 88, we take the 24-th bit of R, which is 1
Because the R bit is 1 it is flipped and S is inverted. They become
R = 0010100110110011000000100111010011101110000001101010111010111111
S=00000001110110001111011001100111000100100000100101000000110011001100100010111000101010011111010110011101000011001011011001111101001011111000000001111010101010000010101000110010100011111011101011101100010110000101001000100111001110101010101010001
Our work has ended, in 290 steps and using 245 bits for the state machine. The message was
1001101101000010000011010111101001110001111010111110011100000110000111100111110011100001
and the resulting hash is
0010100110110011000000100111010011101110000001101010111010111111