The Legend of Satoshi Nakamato, FINAL STEP PUBLISHED.... 4.87 BTC GRAND PRIZE!

[Pan Troglodytes]

Have you tried using the inner shape as the third bit (skinny line or blob of paint)?

you mean something like this:

Code:

short/long  01101101101000101101101100111101111101101101111100101000111000101101111101111101111100111001101101101101101000101101111100101000111100101100111001101100
yellow/red  00010101001011011100101100000000101110111000111100001010111000011100010111111101011100111101001100101001101100110001111000110000101110101100011101110010
green/blue  10001101001010111100001110110111110110010000101101000000110011011100011000101010011110010000001110100100010111111111011000011111101001011011010010101000
slim/fat    01001100001100011101011101011100001110001101011100010000111111000110011000100011010000011001001101001100011000101001011100011111110100111011011000111100

it is a possibility, in some cases the blobs (slim/fat) look like there were corrected.

It is extremely interesting. Maybe even a breakthrough post, for me. If you divide it in groups of 6 (exactly how alphabetcanary did for lengths earlier) you'll notice that the same patterns reoccure all over again:

Look:

Code:

slim/fat   
010011
000011
000111
010111
010111
000011
100011
010111
000100
001111
110001
100110
001000
110100
000110
010011
010011
000110
001010
010111
000111
111101
001110
110110
001111
00

I am not sure what to do with that (yet, I hope), just sharing what I noticed

[alphabetacanary]

It is extremely interesting. Maybe even a breakthrough post, for me. If you divide it in groups of 6 (exactly how alphabetcanary did for lengths earlier) you'll notice that the same patterns reoccure all over again:

Wow, actually that would be a game changer if true!  I will try to verify.

[zbyszek2]

I would like to share some statistics I've made,
the conclusion: It is not possible that the "yellow/red", "green/blue" bits (only) encode a  private key
(or at least very unlikely)
(EDIT: see bottom comment)

looking at the distribution of  1's in the "yellow/red", "green/blue" bit streams it looks like the stream is random

Code:

yellow/red  00010101001011011100101100000000101110111000111100001010111000011100010111111101011100111101001100101001101100110001111000110000101110101100011101110010
green/blue  10001101001010111100001110110111110110010000101101000000110011011100011000101010011110010000001110100100010111111111011000011111101001011011010010101000

we have 78 - 1's in "yellow/red" stream and 77 -1's in "green/blue" stream (nearly 50% of all 152x2 bits)
but if we take only bits if a flame is long:

Code:

short/long  01101101101000101101101100111101111101101101111100101000111000101101111101111101111100111001101101101101101000101101111100101000111100101100111001101100
yellow/red   00 01 10 1   0 11 01 11  0000 01011 01 10 01111  0 1   111   0 11 00101 11111 10111  111  10 11 01 10 11 1   1 00 11110  1 0   1011  1 11  011  11 00 
green/blue   00 11 10 1   1 11 00 11  1101 11101 00 00 01011  0 0   110   0 11 00110 01010 00111  010  00 11 01 01 00 0   1 11 10110  0 1   1010  0 10  010  01 10  

we get:
P(yellow/red = 1 | long) = 0,6559139785
P(green/blue = 1 | long) = 0,5161290323
this is very strange (assuming the streams are random) but still possible, so let just check every second bit and cut out only bits according to 011011 pattern:

Code:

pattern     0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 
yellow/red    0 0   0 1   0 1   1 1   0 0   1 1   1 1   1 1   0 1   1 1   0 1   0 0   1 1   0 1   1 1   0 1   1 1   1 1   1 0   1 1   1 0   1 1   1 1   0 1   1 0   
green/blue    0 1   0 1   1 1   0 1   1 0   1 0   0 0   1 1   0 0   1 0   0 1   0 1   1 1   0 1   0 0   0 1   1 0   0 0   1 1   0 1   0 1   1 1   0 1   0 0   1 1   

P(yellow/red = 1 | '0 1 1' = 1) = 0,68
P(green/blue = 1 | '0 1 1' = 1) = 0,52
this is very unlikely to happen for a private key, how unlikely?
I've tested 1000 WIF private keys generated with vanitygen in base64, base58 and binary coding,  the highest P(private key = 1| '0 1 1' = 1) was ~0.62

Here are my statistics:
1. average P for a private key generated with vanitygen (1000 samples)

Code:

vanity key  bin            base64          base58         ascii 7bit     ascii 8bit
avr         0,4910042715   0,4928240574    0,4593443252	  0,538281408	 0,470996232

2. P for short/long, yellow/red, green/blue and slim/fat bit streams with cutouts (columns)
https://imgur.com/gallery/JRZFs

Code:

		all		'10101010’	'01010101’	1 1 0 1 1	0 0 1 0 0	short/long 1	short/long 0	yellow/red 1	yellow/red 0	green/blue 0	green/blue 1	slim/fat 1	slim/fat 0
short/long	0,6118421053	0,6578947368	0,5657894737	1		0		1		0		0,7820512821	0,4324324324	0,6233766234	0,6		0,7333333333	0,4935064935
yellow/red	0,5131578947	0,5263157895	0,5		0,68		0,2307692308	0,6559139785	0,2881355932	1		0		0,5584415584	0,4666666667	0,56		0,4675324675
green/blue	0,5065789474	0,5263157895	0,4868421053	0,52		0,5384615385	0,5161290323	0,4915254237	0,5512820513	0,4594594595	1		0		0,6266666667	0,3896103896
slim/fat	0,4934210526	0,4210526316	0,5657894737	0,52		0,2307692308	0,5913978495	0,3389830508	0,5384615385	0,4459459459	0,6103896104	0,3733333333	1		0
Bit count	152		76		76		50		26		93		59		74		78		77		75		75		77

in case of 2. we can clearly see there is a correlation between  "short/long" -  "yellow/red" streams and "green/blue" - "slim/fat" streams


EDIT:
In this analysis I assumed that the private key is random, but that is not necessarily true,
in fact we only need 42bits of "randomnes" to generate a public key with a "1FLAMEN6" prefix,
so after all my main conclusion is probably wrong

[bug.lady]

Of course it does leave 51 chars in base58 encoding. It is by no means surprising. As I said above, 152 flames, if you assume a flame codes only 2 bits i. e. two colors, inner and outer (with length bits EXCLUDED, exactly how you did exclude length information but using a different method), code 304 bits which is exactly the WIF length and as I said above, this is exactly the reason this theory was so appealing to many forum members (around page 29 of this thread I think)

Just to clarify terminology, WIF format is not 304 bits (my mistake on a previous post too, BTW). 

WIF implies a base58 encoding because it's the format you import into a wallet.  In this case, it would be either 306 bits for a non-compressed version and 312 for compressed version assuming 6 bits per char.

"assuming 6 bits per char". And it is a big assumption. In reality WIF IS 304 bits, consult with http://lenschulwitz.com/base58 and try to decode a sample WIF into the HEX and vice versa. If it were 306 bits it wouldn't decode to 38 byte (76 digit) HEX which is 304 bit only.

If we are on the level of terminology, the more accurate statement would be that WIF is a 51 char string with certain chars excluded.

This is all off-topic, just to be on the same page discussing terminology

[alphabetacanary]

If we are on the level of terminology, the more accurate statement would be that WIF is a 51 char string with certain chars excluded.

Yep, you're right.  WIF as 306 bits doesn't really exist outside my convenient mapping from 6 bits onto base58 space.  So my 306 bit definition fails   I take it back.

[sini]

If we are on the level of terminology, the more accurate statement would be that WIF is a 51 char string with certain chars excluded.

Yep, you're right.  WIF as 306 bits doesn't really exist outside my convenient mapping from 6 bits onto base58 space.  So my 306 bit definition fails   I take it back.

I mean. Isn't that expected? When encoding values using Bacon you use 5 bits but you only have a dictionary of the characters you need.

[Pan Troglodytes]

I would like to share some statistics I've made,
the conclusion: It is not possible that the "yellow/red", "green/blue" bits (only) encode a  private key
(or at least very unlikely)
(....)

congrats on your in-depth analysis and profound conclusions, Zbyszek. And thanks for sharing that

EDIT: still, they can be a mapping into more random data (a board has been mentioned)

[white_[x]_rabbit]

You think very predictably
That was what it was about creating these puzzles

[bug.lady]

You think very predictably
That was what it was about creating these puzzles

said Yoda

[CompNeuro]

OK, I'll share what I've had for a bit in the interest of getting to solve this. I just hope fellow puzzle enthusiast strangers on the internet can acknowledge the contributions of others.
I'm pretty positive it's a DNA/RNA encoding to amino acids (protein building blocks) in some fashion.

- The game of life/life/love topic is relevant.
- The WR portal with the QR code from an earlier stage featured a colored blob. It definitely looks like a volume filled protein structure. Not sure which one.
- DNA/RNA has 4 symbols ('atcg' or 'aucg'), is read three units (called bases) at a time, and there are 21 proteins (indicated by one letter abbreviations).
- The three drips on the chess piece could indicate a reading frame, which tells you how to chunk the bases. A different start point will lead to different amino acids, so this is important.
- DNA/RNA has stop codons, which indicate when to stop making a protein. These can either be delimiters between words, or be considered by their pigment based names (amber, ochre, opal).

Consider only the 4 color combinations of the flames (RB RG YB YG) and treat them as bases (atcg).
Consider the permutations of the bases, reading order of the strips, and reading direction.
Consider reading frames (just in case).

Just looking at the inner colored flames, many combinations will produce keys within the range of a minikey (~29 or 30, with/without omitting stops).
Combining the inner and outer colored flames, all combinations are within range of a privkey, as has been noted (50, without omitting stops).

The question is if this is a key:
What start, order, and direction (and maybe frame, if it changes per strip), and if capitalization is also encoded somehow.

Stuff to rule out:
If DNA/RNA, there is an amino acid that indicates when to start, but I've tried those keys.
I've read according to the spirals, and combos of CCW & CW, as well as many other combos.
Some combinations and starts do indeed encode BIP38 beginnings, but I haven't gotten anywhere fruitful.
Using the ribbons as capitalization doesn't work.
Inner triplets are not consistently one height, if flame height encodes capitalization.
I don't see a pattern in the outer flames that would indicate how to capitalize the inner flames.

If it's not a key:
Translating it could also produce a phrase which points to the next step, and there are legible words (and maybe phrases) in the most likely permutation and frame, but not all of them are. There is one word which relates directly to the painting when unscrambled. Substitution, rearrangement as an anagram, caesar, and vigenère don't go anywhere as a whole that I can see.

[zbyszek2]

EDIT: still, they can be a mapping into more random data (a board has been mentioned)

Yes, that's what I'm suspecting too

[Pan Troglodytes]

It is extremely interesting. Maybe even a breakthrough post, for me. If you divide it in groups of 6 (exactly how alphabetcanary did for lengths earlier) you'll notice that the same patterns reoccure all over again:

Wow, actually that would be a game changer if true!  I will try to verify.

the reocurring patterns are as follow:

Code:

blob bit string	hex representation	count
010011		13				3
000011		03				2
000111		07				2
010111		17				4
010111		17				4
000011		03				2
100011		23				1
010111		17				4
000100		04				1
001111		0F				2
110001		31				1
100110		26				1
001000		08				1
110100		34				1
000110		06				2
010011		13				3
010011		13				3
000110		06				2
001010		0A				1
010111		17				4
000111		07				2
111101		3D				1
001110		0E				1
110110		36				1
001111		0F				2
00		0				-

not very random

[alphabetacanary]

[the reocurring patterns are as follow:

Actually, on second look, I don't think this is statistically significant.  Out of a sample of 25, you have 16 unique values which is not surprising.  You're bound to get repeats even if you look at random data.  If the sample size was much larger and you still got few values, that would mean something more I think.  But that doesn't mean the thin/thick data can't also be part of the solution.

[Pan Troglodytes]

[the reocurring patterns are as follow:

Actually, on second look, I don't think this is statistically significant.  Out of a sample of 25, you have 16 unique values which is not surprising.  You're bound to get repeats even if you look at random data.  If the sample size was much larger and you still got few values, that would mean something more I think.  But that doesn't mean the thin/thick data can't also be part of the solution.

well, don't forget you are taking it out of 6 bit pool, which has 64 possible values (if I am not mistaken that late at night). If they were taken randomly from a pool of a milion values, would you still expect to have 9 repeats? If so, I should ask you to mark your numbers on my next lotto coupon Anyway, I am going to pursue that path for a while and you will do what you choose, but I will just not do it tonight anymore

[kn0w0n3]

There is a short colored flame, and it appears as though it was originally a long colored flame. In both the tiff and the jpeg it looks like this flame was corrected. This flame also happens to be an odd numbered flame, which leads me to believe that the lengths of the odd numbered flames are still important.

Other then that, I spent a fair amount of time today trying to apply Bacon's cypher to various portions of the flames in all sorts of different ways and didn't find anything.

In case anyone wants here is the, somewhat lazily written, code I used today. Those who think a bacon cypher was used may find it useful, it has several options that you should be able to figure out how to use.., but if not feel free to ask.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* shift(char* string);
int getlines(FILE* stream, char** line, ssize_t* nread, int* ntot, size_t len);
char* normalize(char* string, int nflag);
void divideString(char* string);
void debacon(char* string, int btype);
void flip(char* string);
int verbose = 0;


int main(int argc, char* argv[]){
	FILE* scram;
	int nflag = 0;
	int btype = 0;
	int bitflip = 0;
	char* line[16];
	int i = 0;
	int j = 0;
	int k = 0;
	size_t len = 0;
	ssize_t nread[16];
	int ntot = 0;
	char buffer[1024];

	if (argc < 3 || argc > 6){
		printf("\nERROR: Must specify input file and bacon alphabet\n");
		printf("\nUSAGE: ./debacon path_to_input_file bacon_alphabet_A_or_B normalize_type_0_1_2_3 flip_bits_t_or_f\n");
		printf("\nUSAGE: Specify -v after all options for verbose mode\n");
		printf("\nEXAMPLE: ./debacon file a 2 f -v\n");
		exit(EXIT_FAILURE);
	}

	if(argv[2][0] == 'b' || argv[2][0] == 'B'){
		btype = 1;
	}

	if(argc > 3){
		if(atoi(argv[3]) < 4){
			nflag = atoi(argv[3]);
		}
	       	if(argv[3][0] == 't' || argv[3][0] == 'T'){
			bitflip = 1;
		}	
		if(argv[3][1] == 'v' || argv[3][1] == 'V'){
			printf("\nTurning on Verbose Mode...\n");
			verbose = 1;
		}
	}

	if(argc > 4){
		if(argv[4][0] == 't' || argv[4][0] == 'T'){
			bitflip = 1;
		}
		if(argv[4][1] == 'v' || argv[4][1] == 'V'){
			printf("\nTurning on Verbose Mode...\n");
			verbose = 1;
		}
	}

	if(argc > 5){
		if(argv[5][1] == 'v' || argv[5][1] == 'V'){
			printf("\nTurning on Verbose Mode...\n");
			verbose = 1;
		}
	}

	scram = fopen(argv[1], "r");

	i = getlines(scram, line, nread, &ntot, len);
	
	if(verbose == 1){
		for(j = 0; j < i; j++){
			printf("Retrieved line of length %zu:\n", nread[j]);
			printf("line %i is: %s\n", j, line[j]);
		}
		printf("Total Characters Read: %i\n\n", ntot);
		j = 0;
	}

	for(j = 0; j < i; j++){
		if(verbose == 1){
			printf("Normalizeing line %i\n", j);
		}
		if(bitflip == 1){
			flip(line[j]);
		}
		line[j] = normalize(line[j], nflag);
		if(verbose == 1){
			printf("Line %i is now: %s\n", j, line[j]);
		}
	}

	j = 1;
	strcpy(buffer, line[0]);
	for(j = 1; j < i; j++){
		strcat(buffer, line[j]);
	}

	if(verbose == 1){
		printf("\nCombined String: %s\n", buffer);
	}
	for(k = 0; k <= strlen(buffer); k++){
		divideString(buffer);
		if(verbose == 1){
			printf("\nString split into 5's for decoding:\n");
			printf("%s\n", buffer);

			printf("\nDebaconing:\n");
		}
		debacon(buffer, btype);

		shift(buffer);
	}

	for(; i > 0; i--){
		free(line[i-1]);
	}
	fclose(scram);
	exit(EXIT_SUCCESS);

}

void flip(char *string){
	char *i;
	for(i=string; *i; i++){
		if(*i == '1'){
			*i = '0';
		} else if(*i == '0'){
			*i = '1';
		}
	}
}

void debacon(char *string, int btype){
	char buffer[6];
	int i = 0;

	while(string[i] != '\0'){

		buffer[0] = string[i];
		i++;
		buffer[1] = string[i];		
		i++;
		buffer[2] = string[i];
		i++;
		buffer[3] = string[i];
		i++;
		buffer[4] = string[i];
		buffer[5] = '\0';
		i+=2;

		if(btype == 0){
			if(strcmp(buffer, "00000") == 0){
				printf("A");
			} else if(strcmp(buffer, "00001") == 0){
				printf("B");
			} else if(strcmp(buffer, "00010") == 0){
				printf("C");
			} else if(strcmp(buffer, "00011") == 0){
				printf("D");
			} else if(strcmp(buffer, "00100") == 0){
				printf("E");
			} else if(strcmp(buffer, "00101") == 0){
				printf("F");
			} else if(strcmp(buffer, "00110") == 0){
				printf("G");
			} else if(strcmp(buffer, "00111") == 0){
				printf("H");
			} else if(strcmp(buffer, "01000") == 0){
				printf("J");
			} else if(strcmp(buffer, "01001") == 0){
				printf("K");
			} else if(strcmp(buffer, "01010") == 0){
				printf("L");
			} else if(strcmp(buffer, "01011") == 0){
				printf("M");
			} else if(strcmp(buffer, "01100") == 0){
				printf("N");
			} else if(strcmp(buffer, "01101") == 0){
				printf("O");
			} else if(strcmp(buffer, "01110") == 0){
				printf("P");
			} else if(strcmp(buffer, "01111") == 0){
				printf("Q");
			} else if(strcmp(buffer, "10000") == 0){
				printf("R");
			} else if(strcmp(buffer, "10001") == 0){
				printf("S");
			} else if(strcmp(buffer, "10010") == 0){
				printf("T");
			} else if(strcmp(buffer, "10011") == 0){
				printf("V");
			} else if(strcmp(buffer, "10100") == 0){
				printf("W");
			} else if(strcmp(buffer, "10101") == 0){
				printf("X");
			} else if(strcmp(buffer, "10110") == 0){
				printf("Y");
			} else if(strcmp(buffer, "10111") == 0){
				printf("Z");
			} else{
				printf(" ");
			}
		}
		if(btype == 1){
			if(strcmp(buffer, "00000") == 0){
				printf("A");
			} else if(strcmp(buffer, "00001") == 0){
				printf("B");
			} else if(strcmp(buffer, "00010") == 0){
				printf("C");
			} else if(strcmp(buffer, "00011") == 0){
				printf("D");
			} else if(strcmp(buffer, "00100") == 0){
				printf("E");
			} else if(strcmp(buffer, "00101") == 0){
				printf("F");
			} else if(strcmp(buffer, "00110") == 0){
				printf("G");
			} else if(strcmp(buffer, "00111") == 0){
				printf("H");
			} else if(strcmp(buffer, "01000") == 0){
				printf("I");
			} else if(strcmp(buffer, "01001") == 0){
				printf("J");
			} else if(strcmp(buffer, "01010") == 0){
				printf("K");
			} else if(strcmp(buffer, "01011") == 0){
				printf("L");
			} else if(strcmp(buffer, "01100") == 0){
				printf("M");
			} else if(strcmp(buffer, "01101") == 0){
				printf("N");
			} else if(strcmp(buffer, "01110") == 0){
				printf("O");
			} else if(strcmp(buffer, "01111") == 0){
				printf("P");
			} else if(strcmp(buffer, "10000") == 0){
				printf("Q");
			} else if(strcmp(buffer, "10001") == 0){
				printf("R");
			} else if(strcmp(buffer, "10010") == 0){
				printf("S");
			} else if(strcmp(buffer, "10011") == 0){
				printf("T");
			} else if(strcmp(buffer, "10100") == 0){
				printf("U");
			} else if(strcmp(buffer, "10101") == 0){
				printf("V");
			} else if(strcmp(buffer, "10110") == 0){
				printf("W");
			} else if(strcmp(buffer, "10111") == 0){
				printf("X");
			} else if(strcmp(buffer, "11000") == 0){
				printf("Y");
			} else if(strcmp(buffer, "11001") == 0){
				printf("Z");
			} else{
				printf(" ");
			}
		}
	}
	printf("\n");
}

void divideString(char *string){
	int size = strlen(string);
	int i = 1;
	int j = 1;
	int psize;
	char buffer[1024];
	
	strcpy(buffer,string);
	string[0] = buffer[0];

	for(i = 1; j < size; i++){
		if(j%5 == 0){
			string[i] = ' ';
			i++;
		}
			string[i] = buffer[j];
			j++;
	}
	string[i + 1] = '\0';
}

char* normalize(char* string, int nflag){
	char *i;
	switch(nflag){
		case 0:
			for(i=string; *i; i++){
				if(*i == 'y'){
					*i = '1';
				} else if(*i == 'o'){
					*i = '0';
				} else if(*i == 'g'){
					*i = '1';
				} else if(*i == 'p'){
					*i = '0';
				} else if(*i == '\n'){
					*i = '\0';
				}
			}
			return string;
		case 1:
			for(i=string; *i; i++){
				if(*i == 'y'){
					*i = '0';
				} else if(*i == 'o'){
					*i == '1';
				} else if(*i == 'g'){
					*i = '1';
				} else if(*i == 'p'){
					*i = '0';
				} else if(*i == '\n'){
					*i == '\0';
				}
			}
			return string;
		case 2:
			for(i=string; *i; i++){
				if(*i == 'y'){
					*i = '1';
				} else if(*i == 'o'){
					*i = '0';
				} else if(*i == 'g'){
					*i == '0';
				} else if(*i == 'p'){
					*i == '1';
				} else if(*i == '\n'){
					*i = '\0';
				}
			}
			return string;
		case 3:
			for(i=string; *i; i++){
				if(*i == 'y'){
					*i = '0';
				}else if(*i == 'o'){
					*i = '1';
				} else if(*i == 'g'){
					*i = '0';
				} else if(*i == 'p'){
					*i = '1';
				} else if(*i == '\n'){
					*i = '\0';
				}
			}
			return string;
		default:
			printf("\nERROR: Could not normalize stirng\n");
			return string;
	}
}

int getlines(FILE* stream, char** line, ssize_t* nread, int* ntot, size_t len){
	int i = 0;
	for(i = 0; i < 16; i++){
		nread[i] = getline(&line[i], &len, stream);
		if(nread[i] == -1){
			break;
		}
		*ntot += nread[i];
	}
	
	return i;
}

char* shift(char* string){
	char *nospace = string;
	char *temp = string;
	char buffer[1024];
	buffer;
	char t;
	int i = 0;
	int size;

	if(verbose == 1){
		printf("\nRemoving Spaces\n");
	}
	while(*temp != 0){
		*nospace = *temp++;
		if(*nospace != ' '){
			nospace++;
		}
	}
	*nospace = 0;
	if(verbose == 1){
		printf("\n%s\n", string);
		printf("\nShifting String\n");
	}
	strcpy(buffer, string);
	if(verbose == 1){
		printf("Buffer: \n%s\n\n", buffer);
	}
	t = string[0];
	size = strlen(string);
	for(i = 0; i < (size-1); i++){
		string[i] = buffer[i+1];
	}
	string[i] = t;
	string[i+1] = '\0';
	if(verbose == 1){
		printf("%s\n", string);
	}
}

You can feed the program a text file with up to 16 lines, like below. Note though, I didn't dynamically allocate memory, so you are limited to using a character buffer of size 1024 (Which honestly should be more then enough for anything from this puzzle). Also, I didn't do anything fancy as far as combining the lines go, it just concatenates them together, and shifts the bits by 1 each iteration.

001110
010001011010
110111
010011001110100010010
oyoooyooyoo
oooogppggppgppgp
pgpgppgg

And it'll output something like this

Code:

HELLOTHISISATEST
OIWW GOREREBGJFG
 RNN M CJCICMSKM
ZC  UZ ESEQEZEUZ
SFVXJTUJEJAJSJJT
ELLOTHISISATESTH
IWW GOREREBGJFGO
RNN M CJCICMSKM 
C  UZ ESEQEZEUZZ
FVXJTUJEJAJSJJTS
LLOTHISISATESTHE
WW GOREREBGJFGOI
NN M CJCICMSKM R
  UZ ESEQEZEUZZC
VXJTUJEJAJSJJTSF
LOTHISISATESTHEL
W GOREREBGJFGOIW
N M CJCICMSKM RN
 UZ ESEQEZEUZZC 
XJTUJEJAJSJJTSFV
OTHISISATESTHELL
 GOREREBGJFGOIWW
 M CJCICMSKM RNN
UZ ESEQEZEUZZC  
JTUJEJAJSJJTSFVX
THISISATESTHELLO
GOREREBGJFGOIWW 
M CJCICMSKM RNN 
Z ESEQEZEUZZC  U
TUJEJAJSJJTSFVXJ
HISISATESTHELLOT
OREREBGJFGOIWW G
 CJCICMSKM RNN M
 ESEQEZEUZZC  UZ
UJEJAJSJJTSFVXJT
ISISATESTHELLOTH
REREBGJFGOIWW GO
CJCICMSKM RNN M 
ESEQEZEUZZC  UZ 
JEJAJSJJTSFVXJTU
SISATESTHELLOTHI
EREBGJFGOIWW GOR
JCICMSKM RNN M C
SEQEZEUZZC  UZ E
EJAJSJJTSFVXJTUJ
ISATESTHELLOTHIS
REBGJFGOIWW GORE
CICMSKM RNN M CJ
EQEZEUZZC  UZ ES
JAJSJJTSFVXJTUJE
SATESTHELLOTHISI

[feedo]

yari shogi

Fixed for you..., blind and stupid.

to the blind double standard moderator who deleted my comment:
why you didn't see the comment above and delete it?

[feedo]

- DNA/RNA has 4 symbols ('atcg' or 'aucg'), is read three units (called bases) at a time, and there are 21 proteins (indicated by one letter abbreviations).
- The three drips on the chess piece could indicate a reading frame, which tells you how to chunk the bases. A different start point will lead to different amino acids, so this is important.
- DNA/RNA has stop codons, which indicate when to stop making a protein. These can either be delimiters between words, or be considered by their pigment based names (amber, ochre, opal).

seriously? don't tell me that coin-artist have a Phd in medicine or biochemistry
your post could be a good lecture, but of course not here.

[smracer]

- DNA/RNA has 4 symbols ('atcg' or 'aucg'), is read three units (called bases) at a time, and there are 21 proteins (indicated by one letter abbreviations).
- The three drips on the chess piece could indicate a reading frame, which tells you how to chunk the bases. A different start point will lead to different amino acids, so this is important.
- DNA/RNA has stop codons, which indicate when to stop making a protein. These can either be delimiters between words, or be considered by their pigment based names (amber, ochre, opal).

seriously? don't tell me that coin-artist have a Phd in medicine or biochemistry
your post could be a good lecture, but of course not here.

Rob Myers is the mastermind behind the puzzle.

I read a lot of his work and found he mentioned Peter Saville in one of his blogs.

http://yewknee.com/blog/peter-saville-colour-code/

[feedo]

- DNA/RNA has 4 symbols ('atcg' or 'aucg'), is read three units (called bases) at a time, and there are 21 proteins (indicated by one letter abbreviations).
- The three drips on the chess piece could indicate a reading frame, which tells you how to chunk the bases. A different start point will lead to different amino acids, so this is important.
- DNA/RNA has stop codons, which indicate when to stop making a protein. These can either be delimiters between words, or be considered by their pigment based names (amber, ochre, opal).

seriously? don't tell me that coin-artist have a Phd in medicine or biochemistry
your post could be a good lecture, but of course not here.

Rob Myers is the mastermind behind the puzzle.

I read a lot of his work and found he mentioned Peter Saville in one of his blogs.

http://yewknee.com/blog/peter-saville-colour-code/

I know, but i don't think he wrote something about DNA/RNA stop codons!

[CompNeuro]

- DNA/RNA has 4 symbols ('atcg' or 'aucg'), is read three units (called bases) at a time, and there are 21 proteins (indicated by one letter abbreviations).
- The three drips on the chess piece could indicate a reading frame, which tells you how to chunk the bases. A different start point will lead to different amino acids, so this is important.
- DNA/RNA has stop codons, which indicate when to stop making a protein. These can either be delimiters between words, or be considered by their pigment based names (amber, ochre, opal).

seriously? don't tell me that coin-artist have a Phd in medicine or biochemistry
your post could be a good lecture, but of course not here.

It's literally done for you here, no brain power or PhD involved.
https://www.dcode.fr/codons-genetic-code

I don't think it's that far-fetched.