No bitsize of result set (use &b= to set it), using 512 bits as a default.

The [M]essage chosen 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

and the resulting hash is