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

[chubbychew]

Man, I need to check my code... So the encouraging news is that this is a somewhat new approach. Yay. Here's the bacon I get after the xor-ing.

AEIEMHAZYGPBBLMHJCSIQXADYMOZ can anyone verify this result? I've made many code errors and even checking by hand is hard with this many steps.

[1713569102]

1713569102

[1713569102]

1713569102

[1713569102]

1713569102

[kn0w0n3]

So what are you waiting? Go ahead you have a big homework and weeks ahead to play with your lovely flames  

You do realize that it doesn't take much time at all to test something like this right?

Input Data:

Code:

0yp1yg1yg0og1yp1op0yg1op1yg0yg1op0yg0op0og1yp0op1op1op0yg1yg10g0yg1op1op0yp0yg1yp1yp
1yg1yp0yp1yp1op1yp1og1op0op1yg1og0op1og1yg0yg1yg1op1og1op1op0yg0yp1yg0yg
1og0yg0og0yg1op1op1og0yg0yp0yp1yg0op1op1op0yg1yg1yg1op1yp1og0og1og1op1og1op1og0yp1og1yg1op1op1op0yp
0yp1og1op1og0og0yg1og1yg0yg1op1op0yp1yg
1op0yg1og1yp0yg1og1og0yp
1og0op0yp0yp1op0op1yp1yp0yp1op1og1op1op1yg0yg0yg
1og0op1yp0yp0yp0yp1op1yg1op1og0og0yp
1og0yp1op1og0yp0yp1yg1op1og0og0yp1og1op0og1yp1yg0og0yg

Ran a bunch of different bacon cyphers using this input (no xor) and didn't see anything interesting (I'd post the output, but it exceeds character limit)

@ChubbyChew, After I get off work tonight I'll make it so that my code xor's bitstrings and I'll verify your result.., Although, I'm not sure why you want to verify that?

[feedo]

Yay

I like this lady  

[chubbychew]

@ChubbyChew, After I get off work tonight I'll make it so that my code xor's bitstrings and I'll verify your result.., Although, I'm not sure why you want to verify that?

I am not a programmer and only learn what I need to do quick little jobs. I'm using python and if that result is not correct then I will need to redo all my previous experiments. I'm not used to concatenating binary values and operating on elements of strings. I was hacking up ontherealMF code I didn't fully understand. I appreciate the help.

[Anti-Cen]

The man stated CPU-War which pleases Intel and AMD along with big oil which is happy with the energy costs and we have a system
that won't scale which they knew all along and the highest cost of storing 250 bytes of data since even before 48k
ZX-Spectrum's were invented by Clive Sinclair

Yes the "Block Chain" was so good that the new buzz word in the Lightning network has now become "Off-Block" and
really this was his only great achievement not that read only data was not around years before that but I must admit
he did it in a better way than us programmers did it before his invention.

Satoshi Nakamato must be 99 years old because this post seems to drop of the front page and keeps getting
resurrected quite a lot and I am starting to think he must be Jesus or something.

Sorry guys but I will only give him six out of ten and the chances are he was working the the CIA or MOSSAD
anyway.

 

[hodld0r]

bro i think youve cracked it

[kn0w0n3]

@chubbychew, I have updated my code (posted below) so that it can xor bitstrings. That said, I did not find your string "AEIEMHAZYGPBBLMHJCSIQXADYMOZ "

Here is my code:

debacon.c

Code:

#include "cyphers.h"

int main(int argc, char* argv[]){
	FILE* scram;
	int opt;
	int fcheck = 0;
	int nflag = 0;
	int btype = 0;
	int bitflip = 0;
	char** line = malloc(sizeof(char *) * 16);
	int i = 0;
	int j = 0;
	int k = 0;
	size_t len = 0;
	int ntot = 0;
	char* buffer;
	char* bitstring;
	char* temp;
	int runBacon = 0;
	int runHex = 0;
	int xorit = 0;
	int runDNA = 0;
	int runRNA = 0;
	int verbose = 0;

	while((opt = getopt(argc, argv, "hvf:a:n:i:x:HBDR")) != -1){
		switch(opt){
			case 'h':
				printf("\nUSAGE: ./decode -f path_to_input_file type_of_decode options\n");
				printf("OPTIONS: -f [FILENAME] to specify input file\n");
				printf("OPTIONS: -v for verbose mode\n");
				printf("OPTIONS: -a [a or b] to specify which type of bacon alphebet (Bacon Cypher Only)\n");
				printf("OPTIONS: -n [0 or 1 or 2 or 3] to specify how the bitstring should be read\n");
				printf("OPTIONS: -i [t or f] to specify how 0's and 1's are read from the bitstring\n");
				printf("OPTIONS: -x [bitstring] to xor bits with given bitstring\n");
				printf("OPTIONS: -B for Bacon Cypher\n");
				printf("OPTIONS: -H for HEX conversion\n");
				printf("OPTIONS: -D for DNA RNA Stop Codon Cypher Version 1 (Provide Bases or Flame Colors)\n");
				printf("OPTIONS: -R for DNA RNA Stop Codon Cypher Version 2 (Flame Pairs Only)\n");
				printf("OPTIONS: -h displays this menu\n");
				printf("\nEXAMPLE: ./decode -f file -B -a b -n 2 -i f -v\n");
				exit(EXIT_SUCCESS);
			case 'f':
				scram = fopen(optarg, "r");
				fcheck = 1;
				break;
			case 'v':
				printf("\nTurning on Verbose Mode...\n");
				verbose = 1;
				break;
			case 'a':
				if(optarg[0] == 'a' || optarg[0] == 'A'){
					btype = 0;
				} else if(optarg[0] == 'b' || optarg[0] == 'B'){
					btype = 1;
				} else{
					printf("\nERROR: Invalid argument for for -a option, must be a or b\n");
					exit(EXIT_FAILURE);
				}
				break;
			case 'n':
				if(atoi(optarg) < 4){
					nflag = atoi(optarg);
				} else{
					printf("\nERROR: Invalid argument for -n option, must be 0, 1, 2, or 3\n");
				}
				break;
			case 'i':
				if(optarg[0] == 't' || optarg[0] == 'T'){
					bitflip = 1;
				}
				break;
			case 'x':
				xorit = 1;
				bitstring = malloc(sizeof(char*) * strlen(optarg));
				strcpy(bitstring, optarg);
				break;
			case 'B':
				if(runHex == 1){
					printf("\nERROR: Cannot run Bacon Cypher and Hex conversion together\n");
					exit(EXIT_FAILURE);
				} else if(runDNA == 1 || runRNA == 1){
					printf("\nERROR: Cannot run Bacon Cypher and DNA RNA conversion together\n");
					exit(EXIT_FAILURE);
				} else{
					runBacon = 1;
				}
				break;
			case 'H':
				if(runBacon == 1){
					printf("\nERROR: Cannot run Bacon Cypher and Hex conversion together\n");
					exit(EXIT_FAILURE);
				} else if(runDNA== 1 || runRNA == 1){
					printf("\nERROR: Cannot run DNA RNA Cypher and Hex conversion together\n");
					exit(EXIT_FAILURE);
				} else{
					runHex = 1;
				}
				break;
			case 'D':
				if(runHex == 1){
					printf("\nERROR: Cannot run Hex conversion and DNA RNA Cypher together\n");
					exit(EXIT_FAILURE);
				} else if(runBacon == 1){
					printf("\nERROR: Cannot run Bacon Cypher and DNA RNA Cypher together\n");
					exit(EXIT_FAILURE);
				} else if(runRNA == 1){
					printf("\nERROR: Cannot run both versions of DNA RNA Cypher together\n");
					exit(EXIT_FAILURE);
				} else{
					runDNA = 1;
				}
				break;
			case 'R':
				if(runHex == 1){
					printf("\nERROR: Cannot run Hex conversion and DNA RNA Cypher together\n");
					exit(EXIT_FAILURE);
				} else if(runBacon == 1){
					printf("\nERROR: Cannot run Bacon Cypher and DNA RNA Cypher together\n");
					exit(EXIT_FAILURE);
				} else if(runDNA == 1){
					printf("\nERROR: Cannot run both versions of DNA RNA Cypher together\n");
					exit(EXIT_FAILURE);
				} else{
					runRNA = 1;
				}
				break;
			default:
				printf("ERROR: Unrecognized option, try -h\n");
				exit(EXIT_FAILURE);
		}
	}

	if(fcheck == 0){
		printf("ERROR: Must specify input file, try -h\n");
		exit(EXIT_FAILURE);
	} else if(argc <= 3){
		printf("ERROR: Must specify -H, -B, -D or -R.., try -h for help\n");
	}

	i = getlines(scram, &line, &ntot, len);

	if(verbose == 1){
		for(j = 0; j < i; j++){
			printf("line %i is: %s\n", j, line[j]);
		}
		printf("Total Characters Read: %i\n\n", ntot);
		j = 0;
	}

	buffer = malloc(sizeof(char) * ntot * 5);
	temp = malloc(sizeof(char) * ntot * 5);

	if(runDNA == 1){
		for(j = 0; j < i; j++){
			line[j] = normalize(line[j], 8);
		}
		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, 3);
			if(verbose == 1){
				printf("\nString split into 3's for decoding:\n");
				printf("%s\n", buffer);
				printf("\nDNA RNA Cypher Decode\n");
			}
			deRNA(buffer);
			shift(buffer, verbose);
		}
		for(j = 0; j <= i; j++){
			free(line[j]);
		}
		free(line);
		free(buffer);
		free(temp);
		if(xorit == 1){
			free(bitstring);
		}
		fclose(scram);
		return 0;
	} else if(runRNA == 1){
		for(j = 0; j < i; j++){
			line[j] = normalize(line[j], 8);
		}
		j = 1;
		strcpy(buffer, line[0]);
		for(j = 1; j < i; j++){
			strcat(buffer, line[j]);
		}
		for(j = 0; j <= i; j++){
			free(line[j]);
		}
		free(line);
		free(buffer);
		free(temp);
		if(xorit == 1){
			free(bitstring);
		}
		fclose(scram);
		return 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);
        }

	if(xorit == 1){
		if(verbose == 1){
			printf("XORING with %s\n", bitstring);
		}
		xors(buffer, bitstring);
		if(verbose == 1){
			printf("Resulting string %s\n", buffer);
		}
	}

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

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

			shift(buffer, verbose);
		}
	}

	if(runHex == 1){
		for(k = 0; k <= strlen(buffer); k++){
			if(strlen(buffer)%4 != 0){
				switch(strlen(buffer)%4){
					case 1:
						temp[0] = '0';
						temp[1] = '0';
						temp[2] = '0';
						temp[3] = '\0';
						strcat(temp, buffer);
						break;
					case 2:
						temp[0] = '0';
						temp[1] = '0';
						temp[2] = '\0';
						strcat(temp, buffer);
						break;
					case 3:
						temp[0] = '0';
						temp[1] = '\0';
						strcat(temp, buffer);
						break;
					default:
						printf("Something bad happened...\n");
						break;
				}
			} else{
				strcpy(temp, buffer);
			}
			divideString(temp, 4);
			if(verbose == 1){
				printf("\nString split into 4's\n");
				printf("%s\n", temp);
				printf("\nConverting to Hex:\n");
			}
			deHex(temp);
			clean(temp, verbose);
			shift(buffer, verbose);

		}
	}
	j = 0;
	for(j = 0; j <= i; j++){
		free(line[j]);
	}
	free(line);
	if(xorit == 1){
		free(bitstring);
	}
	fclose(scram);
	free(buffer);
	free(temp);
	return 0;
}

cyphers.h

Code:

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

void shift(char* string, int verbose);
int getlines(FILE* stream, char*** line, int* ntot, size_t len);
char* normalize(char* string, int nflag);
void clean(char* string, int verbose);
void divideString(char* string, int n);
void debacon(char* string, int btype);
void flip(char* string);
void deHex(char* string);
void deRNA(char* string);
void xors(char* string1, char* string2);

cyphers.c

Code:

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

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

void deHex(char *string){
        char buffer[5];
        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];
                buffer[4] = '\0';
                i+=2;

                if(strcmp(buffer, "0000") == 0){
                        printf("0");
                } else if(strcmp(buffer, "0001") == 0){
                        printf("1");
                } else if(strcmp(buffer, "0010") == 0){
                        printf("2");
                } else if(strcmp(buffer, "0011") == 0){
                        printf("3");
                } else if(strcmp(buffer, "0100") == 0){
                        printf("4");
                } else if(strcmp(buffer, "0101") == 0){
                        printf("5");
                } else if(strcmp(buffer, "0110") == 0){
                        printf("6");
                } else if(strcmp(buffer, "0111") == 0){
                        printf("7");
                } else if(strcmp(buffer, "1000") == 0){
                        printf("8");
                } else if(strcmp(buffer, "1001") == 0){
                        printf("9");
                } else if(strcmp(buffer, "1010") == 0){
                        printf("A");
                } else if(strcmp(buffer, "1011") == 0){
                        printf("B");
                } else if(strcmp(buffer, "1100") == 0){
                        printf("C");
                } else if(strcmp(buffer, "1101") == 0){
                        ;printf("D");
                } else if(strcmp(buffer, "1110") == 0){
                        printf("E");
                } else if(strcmp(buffer, "1111") == 0){
                        printf("F");
                } else{
                        printf(" ");
                }
        }
        printf("\n");
}

void divideString(char *string, int n){
        int size = strlen(string);
        int i = 1;
        int j = 1;
        char* buffer = malloc(sizeof(char* ) * strlen(string) * 2);

        strcpy(buffer,string);
        string[0] = buffer[0];

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

int getlines(FILE* stream, char*** line, int* ntot, size_t len){
        int i = 0;
	int max = 16;
	ssize_t nread;

	while((nread = getline(&(*line)[i], &len, stream)) != -1){
		if(i == (max-1)){
			max = max*2;
			*line = realloc(*line, sizeof(char*) * max);
			if(*line == NULL){
				printf("ERROR: Memmory Allocation Failed\n");
				exit(EXIT_FAILURE);
			}
		}
		*ntot += (nread - 1);
		i++;
	}
 
        return i;
}

void shift(char* string, int verbose){
        char *nospace = string;
        char *temp = string;
	char* buffer = malloc(sizeof(char* ) * strlen(string) * 2);

        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);
        }
	free(buffer);
}

void clean(char* string, int verbose){
        char *nospace = string;
        char *temp = string;

        if(verbose == 1){
                printf("\nRemoving Spaces\n");
        }
        while(*temp != 0){
                *nospace = *temp++;
                if(*nospace != ' '){
                        nospace++;
                }
        }
        *nospace = 0;
}

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

void deRNA(char *string){
	char buffer[4];
	int i = 0;

	while(string[i] != '\0'){
		buffer[0] = string[i];
		i++;
		buffer[1] = string[i];
		i++;
		buffer[2] = string[i];
		buffer[3] = '\0';
		i+=2;

		if(strcmp(buffer, "yyy") == 0 || strcmp(buffer, "YYY") == 0 || strcmp(buffer, "ttt") == 0 || strcmp(buffer, "TTT") == 0 || strcmp(buffer, "uuu") == 0 || strcmp(buffer, "UUU") == 0){
			printf("F");
		} if(strcmp(buffer, "yyp") == 0 || strcmp(buffer, "YYP") == 0 || strcmp(buffer, "yyb") == 0 || strcmp(buffer, "YYB") == 0 || strcmp(buffer, "ttc") == 0 || strcmp(buffer, "TTC") == 0 || strcmp(buffer, "uuc") == 0 || strcmp(buffer, "UUC") == 0){
			printf("F");
		} if(strcmp(buffer, "yyo") == 0 || strcmp(buffer, "YYO") == 0 || strcmp(buffer, "yyr") == 0 || strcmp(buffer, "YYR") == 0 || strcmp(buffer, "tta") == 0 || strcmp(buffer, "TTA") == 0 || strcmp(buffer, "uua") == 0 || strcmp(buffer, "UUA") == 0){
			printf("L");
		} if(strcmp(buffer, "yyg") == 0 || strcmp(buffer, "YYG") == 0 || strcmp(buffer, "ttg") == 0 || strcmp(buffer, "TTG") == 0 || strcmp(buffer, "uug") == 0 || strcmp(buffer, "UUG") == 0){
			printf("L");
		} if(strcmp(buffer, "pyy") == 0 || strcmp(buffer, "PYY") == 0 || strcmp(buffer, "byy") == 0 || strcmp(buffer, "BYY") == 0 || strcmp(buffer, "ctt") == 0 || strcmp(buffer, "CTT") == 0 || strcmp(buffer, "cuu") == 0 || strcmp(buffer, "CUU") == 0){
			printf("L");
		} if(strcmp(buffer, "pyp") == 0 || strcmp(buffer, "PYP") == 0 || strcmp(buffer, "byb") == 0 || strcmp(buffer, "BYB") == 0 || strcmp(buffer, "ctc") == 0 || strcmp(buffer, "CTC") == 0 || strcmp(buffer, "cuc") == 0 || strcmp(buffer, "CUC") == 0){
			printf("L");
		} if(strcmp(buffer, "pyo") == 0 || strcmp(buffer, "PYO") == 0 || strcmp(buffer, "byo") == 0 || strcmp(buffer, "BYO") == 0 || strcmp(buffer, "pyr") == 0 || strcmp(buffer, "PYR") == 0 || strcmp(buffer, "byr") == 0 || strcmp(buffer, "BYR") == 0 || strcmp(buffer, "cta") == 0 || strcmp(buffer, "CTA") == 0 || strcmp(buffer, "cua") == 0 || strcmp(buffer, "CUA") == 0){
			printf("L");
		} if(strcmp(buffer, "pyg") == 0 || strcmp(buffer, "PYG") == 0 || strcmp(buffer, "byg") == 0 || strcmp(buffer, "bYG") == 0 || strcmp(buffer, "cug") == 0 || strcmp(buffer, "CUG") == 0 || strcmp(buffer, "ctg") == 0 || strcmp(buffer, "CTG") == 0){
			printf("L");
		} if(strcmp(buffer, "oyy") == 0 || strcmp(buffer, "OYY") == 0 || strcmp(buffer, "ryy") == 0 || strcmp(buffer, "RYY") == 0 || strcmp(buffer, "auu") == 0 || strcmp(buffer, "AUU") == 0 || strcmp(buffer, "att") == 0 || strcmp(buffer, "ATT") == 0){
			printf("I");
		} if(strcmp(buffer, "oyp") == 0 || strcmp(buffer, "OYP") == 0 || strcmp(buffer, "oyb") == 0 || strcmp(buffer, "OYB") == 0 || strcmp(buffer, "ryp") == 0 || strcmp(buffer, "RYP") == 0 || strcmp(buffer, "ryb") == 0 || strcmp(buffer, "RYB") == 0 || strcmp(buffer, "atc") == 0 || strcmp(buffer, "ATC") == 0 || strcmp(buffer, "auc") == 0 || strcmp(buffer, "AUC") == 0){
			printf("I");
		} if(strcmp(buffer, "oyo") == 0 || strcmp(buffer, "OYO") == 0 || strcmp(buffer, "ryr") == 0 || strcmp(buffer, "RYR") == 0 || strcmp(buffer, "aua") == 0 || strcmp(buffer, "AUA") == 0 || strcmp(buffer, "ata") == 0 || strcmp(buffer, "ATA") == 0){
			printf("I");
		} if(strcmp(buffer, "oyg") == 0 || strcmp(buffer, "OYG") == 0 || strcmp(buffer, "ryg") == 0 || strcmp(buffer, "RYG") == 0 || strcmp(buffer, "aug") == 0 || strcmp(buffer, "AUG") == 0 || strcmp(buffer, "atg") == 0 || strcmp(buffer, "ATG") == 0){
			printf(" - M - ");
		} if(strcmp(buffer, "gyy") == 0 || strcmp(buffer, "GYY") == 0 || strcmp(buffer, "guu") == 0 || strcmp(buffer, "GUU") == 0 || strcmp(buffer, "gtt") == 0 || strcmp(buffer, "GTT") == 0){
			printf("V");
		} if(strcmp(buffer, "gyp") == 0 || strcmp(buffer, "GYP") == 0 || strcmp(buffer, "gyb") == 0 || strcmp(buffer, "GYB") == 0 || strcmp(buffer, "guc") == 0 || strcmp(buffer, "GUC") == 0 || strcmp(buffer, "gtc") == 0 || strcmp(buffer, "GTC") == 0){
			printf("V");
		} if(strcmp(buffer, "gyo") == 0 || strcmp(buffer, "GYO") == 0 || strcmp(buffer, "gyr") == 0 || strcmp(buffer, "GYR") == 0 || strcmp(buffer, "gua") == 0 || strcmp(buffer, "GUA") == 0 || strcmp(buffer, "gta") == 0 || strcmp(buffer, "GTA") == 0){
			printf("V");
		} if(strcmp(buffer, "gyg") == 0 || strcmp(buffer, "GYG") == 0 || strcmp(buffer, "gug") == 0 || strcmp(buffer, "GUG") == 0 || strcmp(buffer, "gtg") == 0 || strcmp(buffer, "GTG") == 0){
			printf("V");
		} if(strcmp(buffer, "ypy") == 0 || strcmp(buffer, "YPY") == 0 || strcmp(buffer, "yby") == 0 || strcmp(buffer, "YBY") == 0 || strcmp(buffer, "ucu") == 0 || strcmp(buffer, "UCU") == 0 || strcmp(buffer, "tct") == 0 || strcmp(buffer, "TCT") == 0){
			printf("S");
		} if(strcmp(buffer, "ypp") == 0 || strcmp(buffer, "YPP") == 0 || strcmp(buffer, "ybb") == 0 || strcmp(buffer, "YBB") == 0 || strcmp(buffer, "ucc") == 0 || strcmp(buffer, "UCC") == 0 || strcmp(buffer, "tcc") == 0 || strcmp(buffer, "TCC") == 0){
			printf("S");
		} if(strcmp(buffer, "ypo") == 0 || strcmp(buffer, "YPO") == 0 || strcmp(buffer, "ybo") == 0 || strcmp(buffer, "YBO") == 0 || strcmp(buffer, "ypr") == 0 || strcmp(buffer, "YPR") == 0 || strcmp(buffer, "ybr") == 0 || strcmp(buffer, "YBR") == 0 || strcmp(buffer, "uca") == 0 || strcmp(buffer, "UCA") == 0 || strcmp(buffer, "tca") == 0 || strcmp(buffer, "TCA") == 0){
			printf("S");
		} if(strcmp(buffer, "ypg") == 0 || strcmp(buffer, "YPG") == 0 || strcmp(buffer, "ybg") == 0 || strcmp(buffer, "YBG") == 0 || strcmp(buffer, "ucg") == 0 || strcmp(buffer, "UCG") == 0 || strcmp(buffer, "tcg") == 0 || strcmp(buffer, "TCG") == 0){
			printf("S");
		} if(strcmp(buffer, "ppy") == 0 || strcmp(buffer, "PPY") == 0 || strcmp(buffer, "bby") == 0 || strcmp(buffer, "BBY") == 0 || strcmp(buffer, "ccu") == 0 || strcmp(buffer, "CCU") == 0 || strcmp(buffer, "cct") == 0 || strcmp(buffer, "CCT") == 0){
			printf("P");
		} if(strcmp(buffer, "ppp") == 0 || strcmp(buffer, "PPP") == 0 || strcmp(buffer, "bbb") == 0 || strcmp(buffer, "BBB") == 0 || strcmp(buffer, "ccc") == 0 || strcmp(buffer, "CCC") == 0){
			printf("P");
		} if(strcmp(buffer, "ppo") == 0 || strcmp(buffer, "PPO") == 0 || strcmp(buffer, "bbo") == 0 || strcmp(buffer, "BBO") == 0 || strcmp(buffer, "ppr") == 0 || strcmp(buffer, "PPR") == 0 || strcmp(buffer, "bbr") == 0 || strcmp(buffer, "BBR") == 0 || strcmp(buffer, "cca") == 0 || strcmp(buffer, "CCA") == 0){
			printf("P");
		} if(strcmp(buffer, "ppg") == 0 || strcmp(buffer, "PPG") == 0 || strcmp(buffer, "bbg") == 0 || strcmp(buffer, "BBG") == 0 || strcmp(buffer, "ccg") == 0 || strcmp(buffer, "CCG") == 0){
			printf("P");
		} if(strcmp(buffer, "opy") == 0 || strcmp(buffer, "OPY") == 0 || strcmp(buffer, "oby") == 0 || strcmp(buffer, "OBY") == 0 || strcmp(buffer, "rpy") == 0 || strcmp(buffer, "RPY") == 0 || strcmp(buffer, "rby") == 0 || strcmp(buffer, "RBY") == 0 || strcmp(buffer, "acu") == 0 || strcmp(buffer, "ACU") == 0 || strcmp(buffer, "act") == 0 || strcmp(buffer, "ACT") == 0){
			printf("T");
		} if(strcmp(buffer, "opp") == 0 || strcmp(buffer, "OPP") == 0 || strcmp(buffer, "obb") == 0 || strcmp(buffer, "OBB") == 0 || strcmp(buffer, "rpp") == 0 || strcmp(buffer, "RPP") == 0 || strcmp(buffer, "rbb") == 0 || strcmp(buffer, "RBB") == 0 || strcmp(buffer, "acc") == 0 || strcmp(buffer, "ACC") == 0){
			printf("T");
		} if(strcmp(buffer, "opo") == 0 || strcmp(buffer, "OPO") == 0 || strcmp(buffer, "obo") == 0 || strcmp(buffer, "OBO") == 0 || strcmp(buffer, "rpr") == 0 || strcmp(buffer, "RPR") == 0 || strcmp(buffer, "rbr") == 0 || strcmp(buffer, "RBR") == 0 || strcmp(buffer, "aca") == 0 || strcmp(buffer, "ACA") == 0){
			printf("T");
		} if(strcmp(buffer, "opg") == 0 || strcmp(buffer, "OPG") == 0 || strcmp(buffer, "obg") == 0 || strcmp(buffer, "OBG") == 0 || strcmp(buffer, "rpg") == 0 || strcmp(buffer, "RPG") == 0 || strcmp(buffer, "rbg") == 0 || strcmp(buffer, "RBG") == 0 || strcmp(buffer, "acg") == 0 || strcmp(buffer, "ACG") == 0){
			printf("T");
		} if(strcmp(buffer, "gpy") == 0 || strcmp(buffer, "GPY") == 0 || strcmp(buffer, "gby") == 0 || strcmp(buffer, "GBY") == 0 || strcmp(buffer, "gcu") == 0 || strcmp(buffer, "GCU") == 0 || strcmp(buffer, "gct") == 0 || strcmp(buffer, "GCT") == 0){
			printf("A");
		} if(strcmp(buffer, "gpp") == 0 || strcmp(buffer, "GPP") == 0 || strcmp(buffer, "gbb") == 0 || strcmp(buffer, "GBB") == 0 || strcmp(buffer, "gcc") == 0 || strcmp(buffer, "GCC") == 0){
			printf("A");
		} if(strcmp(buffer, "gpo") == 0 || strcmp(buffer, "GPO") == 0 || strcmp(buffer, "gbo") == 0 || strcmp(buffer, "GBO") == 0 || strcmp(buffer, "gpr") == 0 || strcmp(buffer, "GPR") == 0 || strcmp(buffer, "gbr") == 0 || strcmp(buffer, "GBR") == 0 || strcmp(buffer, "gca") == 0 || strcmp(buffer, "GCA") == 0){
			printf("A");
		} if(strcmp(buffer, "gpg") == 0 || strcmp(buffer, "GPG") == 0 || strcmp(buffer, "gbg") == 0 || strcmp(buffer, "GBG") == 0 || strcmp(buffer, "gcg") == 0 || strcmp(buffer, "GCG") == 0){
			printf("A");
		} if(strcmp(buffer, "yoy") == 0 || strcmp(buffer, "YOY") == 0 || strcmp(buffer, "yry") == 0 || strcmp(buffer, "YRY") == 0 || strcmp(buffer, "uau") == 0 || strcmp(buffer, "UAU") == 0 || strcmp(buffer, "tat") == 0 || strcmp(buffer, "TAT") == 0){
			printf("Y");
		} if(strcmp(buffer, "yop") == 0 || strcmp(buffer, "YOP") == 0 || strcmp(buffer, "yob") == 0 || strcmp(buffer, "YOB") == 0 || strcmp(buffer, "yrp") == 0 || strcmp(buffer, "YRP") == 0 || strcmp(buffer, "yrb") == 0 || strcmp(buffer, "YRB") == 0 || strcmp(buffer, "uac") == 0 || strcmp(buffer, "UAC") == 0 || strcmp(buffer, "tac") == 0 || strcmp(buffer, "TAC") == 0){
			printf("Y");
		} if(strcmp(buffer, "yoo") == 0 || strcmp(buffer, "YOO") == 0 || strcmp(buffer, "yrr") == 0 || strcmp(buffer, "YRR") == 0 || strcmp(buffer, "uaa") == 0 || strcmp(buffer, "UAA") == 0 || strcmp(buffer, "taa") == 0 || strcmp(buffer, "TAA") == 0){
			printf(" STOP ");
		} if(strcmp(buffer, "yog") == 0 || strcmp(buffer, "YOG") == 0 || strcmp(buffer, "yrg") == 0 || strcmp(buffer, "YRG") == 0 || strcmp(buffer, "uag") == 0 || strcmp(buffer, "UAG") == 0 || strcmp(buffer, "tag") == 0 || strcmp(buffer, "TAG") == 0){
			printf(" STOP ");
		} if(strcmp(buffer, "poy") == 0 || strcmp(buffer, "POY") == 0 || strcmp(buffer, "boy") == 0 || strcmp(buffer, "BOY") == 0 || strcmp(buffer, "pry") == 0 || strcmp(buffer, "PRY") == 0 || strcmp(buffer, "bry") == 0 || strcmp(buffer, "BRY") == 0 || strcmp(buffer, "cau") == 0 || strcmp(buffer, "CAU") == 0 || strcmp(buffer, "cat") == 0 || strcmp(buffer, "CAT") == 0){
			printf("H");
		} if(strcmp(buffer, "pop") == 0 || strcmp(buffer, "POP") == 0 || strcmp(buffer, "bob") == 0 || strcmp(buffer, "BOB") == 0 || strcmp(buffer, "prp") == 0 || strcmp(buffer, "PRP") == 0 || strcmp(buffer, "brb") == 0 || strcmp(buffer, "BRB") == 0 || strcmp(buffer, "cac") == 0 || strcmp(buffer, "CAC") == 0){
			printf("H");
		} if(strcmp(buffer, "poo") == 0 || strcmp(buffer, "POO") == 0 || strcmp(buffer, "boo") == 0 || strcmp(buffer, "BOO") == 0 || strcmp(buffer, "prr") == 0 || strcmp(buffer, "PRR") == 0 || strcmp(buffer, "brr") == 0 || strcmp(buffer, "BRR") == 0 || strcmp(buffer, "caa") == 0 || strcmp(buffer, "CAA") == 0){
			printf("Q");
		} if(strcmp(buffer, "pog") == 0 || strcmp(buffer, "POG") == 0 || strcmp(buffer, "bog") == 0 || strcmp(buffer, "BOG") == 0 || strcmp(buffer, "prg") == 0 || strcmp(buffer, "PRG") == 0 || strcmp(buffer, "brg") == 0 || strcmp(buffer, "BRG") == 0 || strcmp(buffer, "cag") == 0 || strcmp(buffer, "CAG") == 0){
			printf("Q");
		} if(strcmp(buffer, "ooy") == 0 || strcmp(buffer, "OOY") == 0 || strcmp(buffer, "rry") == 0 || strcmp(buffer, "RRY") == 0 || strcmp(buffer, "aau") == 0 || strcmp(buffer, "AAU") == 0 || strcmp(buffer, "aat") == 0 || strcmp(buffer, "AAT") == 0){
			printf("N");
		} if(strcmp(buffer, "oop") == 0 || strcmp(buffer, "OOP") == 0 || strcmp(buffer, "oob") == 0 || strcmp(buffer, "OOB") == 0 || strcmp(buffer, "rrp") == 0 || strcmp(buffer, "RRP") == 0 || strcmp(buffer, "rrb") == 0 || strcmp(buffer, "RRB") == 0 || strcmp(buffer, "aac") == 0 || strcmp(buffer, "AAC") == 0){
			printf("N");
		} if(strcmp(buffer, "ooo") == 0 || strcmp(buffer, "OOO") == 0 || strcmp(buffer, "rrr") == 0 || strcmp(buffer, "RRR") == 0 || strcmp(buffer, "aaa") == 0 || strcmp(buffer, "AAA") == 0){
			printf("K");
		} if(strcmp(buffer, "oog") == 0 || strcmp(buffer, "OOG") == 0 || strcmp(buffer, "rrg") == 0 || strcmp(buffer, "RRG") == 0 || strcmp(buffer, "aag") == 0 || strcmp(buffer, "AAG") == 0){
			printf("K");
		} if(strcmp(buffer, "goy") == 0 || strcmp(buffer, "GOY") == 0 || strcmp(buffer, "gry") == 0 || strcmp(buffer, "GRY") == 0 || strcmp(buffer, "gau") == 0 || strcmp(buffer, "GAU") == 0 || strcmp(buffer, "gat") == 0 || strcmp(buffer, "GAT") == 0){
			printf("D");
		} if(strcmp(buffer, "gop") == 0 || strcmp(buffer, "GOP") == 0 || strcmp(buffer, "gob") == 0 || strcmp(buffer, "GOB") == 0 || strcmp(buffer, "grp") == 0 || strcmp(buffer, "GRP") == 0 || strcmp(buffer, "grb") == 0 || strcmp(buffer, "GRB") == 0 || strcmp(buffer, "gac") == 0 || strcmp(buffer, "GAC") == 0){
			printf("D");
		} if(strcmp(buffer, "goo") == 0 || strcmp(buffer, "GOO") == 0 || strcmp(buffer, "grr") == 0 || strcmp(buffer, "GRR") == 0 || strcmp(buffer, "gaa") == 0 || strcmp(buffer, "GAA") == 0){
			printf("E");
		} if(strcmp(buffer, "gog") == 0 || strcmp(buffer, "GOG") == 0 || strcmp(buffer, "grg") == 0 || strcmp(buffer, "GRG") == 0 || strcmp(buffer, "gag") == 0 || strcmp(buffer, "GAG") == 0){
			printf("E");
		} if(strcmp(buffer, "ygy") == 0 || strcmp(buffer, "YGY") == 0 || strcmp(buffer, "ugu") == 0 || strcmp(buffer, "UGU") == 0 || strcmp(buffer, "tgt") == 0 || strcmp(buffer, "TGT") == 0){
			printf("C");
		} if(strcmp(buffer, "ygp") == 0 || strcmp(buffer, "YGP") == 0 || strcmp(buffer, "ygb") == 0 || strcmp(buffer, "YGB") == 0 || strcmp(buffer, "ugc") == 0 || strcmp(buffer, "UGC") == 0 || strcmp(buffer, "tgc") == 0 || strcmp(buffer, "TGC") == 0){
			printf("C");
		} if(strcmp(buffer, "ygo") == 0 || strcmp(buffer, "YGO") == 0 || strcmp(buffer, "ygr") == 0 || strcmp(buffer, "YGR") == 0 || strcmp(buffer, "uga") == 0 || strcmp(buffer, "UGA") == 0 || strcmp(buffer, "tga") == 0 || strcmp(buffer, "TGA") == 0){
			printf(" STOP ");
		} if(strcmp(buffer, "ygg") == 0 || strcmp(buffer, "YGG") == 0 || strcmp(buffer, "ugg") == 0 || strcmp(buffer, "UGG") == 0 || strcmp(buffer, "tgg") == 0 || strcmp(buffer, "TGG") == 0){
			printf("W");
		} if(strcmp(buffer, "pgy") == 0 || strcmp(buffer, "PGY") == 0 || strcmp(buffer, "bgy") == 0 || strcmp(buffer, "BGY") == 0 || strcmp(buffer, "cgu") == 0 || strcmp(buffer, "CGU") == 0 || strcmp(buffer, "cgt") == 0 || strcmp(buffer, "CGT") == 0){
			printf("R");
		} if(strcmp(buffer, "pgp") == 0 || strcmp(buffer, "PGP") == 0 || strcmp(buffer, "bgb") == 0 || strcmp(buffer, "BGB") == 0 || strcmp(buffer, "cgc") == 0 || strcmp(buffer, "CGC") == 0){
			printf("R");
		} if(strcmp(buffer, "pgo") == 0 || strcmp(buffer, "PGO") == 0 || strcmp(buffer, "bgo") == 0 || strcmp(buffer, "BGO") == 0 || strcmp(buffer, "pgr") == 0 || strcmp(buffer, "PGR") == 0 || strcmp(buffer, "bgr") == 0 || strcmp(buffer, "BGR") == 0 || strcmp(buffer, "cga") == 0 || strcmp(buffer, "CGA") == 0){
			printf("R");
		} if(strcmp(buffer, "pgg") == 0 || strcmp(buffer, "PGG") == 0 || strcmp(buffer, "bgg") == 0 || strcmp(buffer, "BGG") == 0 || strcmp(buffer, "cgg") == 0 || strcmp(buffer, "CGG") == 0){
			printf("R");
		} if(strcmp(buffer, "ogy") == 0 || strcmp(buffer, "OGY") == 0 || strcmp(buffer, "rgy") == 0 || strcmp(buffer, "RGY") == 0 || strcmp(buffer, "agu") == 0 || strcmp(buffer, "AGU") == 0 || strcmp(buffer, "agt") == 0 || strcmp(buffer, "AGT") == 0){
			printf("S");
		} if(strcmp(buffer, "ogp") == 0 || strcmp(buffer, "OGP") == 0 || strcmp(buffer, "ogb") == 0 || strcmp(buffer, "OGB") == 0 || strcmp(buffer, "rgp") == 0 || strcmp(buffer, "RGP") == 0 || strcmp(buffer, "rgb") == 0 || strcmp(buffer, "RGB") == 0 || strcmp(buffer, "agc") == 0 || strcmp(buffer, "AGC") == 0){
			printf("S");
		} if(strcmp(buffer, "ogo") == 0 || strcmp(buffer, "OGO") == 0 || strcmp(buffer, "rgr") == 0 || strcmp(buffer, "RGR") == 0 || strcmp(buffer, "aga") == 0 || strcmp(buffer, "AGA") == 0){
			printf("R");
		} if(strcmp(buffer, "ogg") == 0 || strcmp(buffer, "OGG") == 0 || strcmp(buffer, "rgg") == 0 || strcmp(buffer, "RGG") == 0 || strcmp(buffer, "agg") == 0 || strcmp(buffer, "AGG") == 0){
			printf("R");
		} if(strcmp(buffer, "ggy") == 0 || strcmp(buffer, "GGY") == 0 || strcmp(buffer, "ggu") == 0 || strcmp(buffer, "GGU") == 0 || strcmp(buffer, "ggt") == 0 || strcmp(buffer, "GGT") == 0){
			printf("G");
		} if(strcmp(buffer, "ggp") == 0 || strcmp(buffer, "GGP") == 0 || strcmp(buffer, "ggb") == 0 || strcmp(buffer, "GGB") == 0 || strcmp(buffer, "ggc") == 0 || strcmp(buffer, "GGC") == 0){
			printf("G");
		} if(strcmp(buffer, "ggo") == 0 || strcmp(buffer, "GGO") == 0 || strcmp(buffer, "ggr") == 0 || strcmp(buffer, "GGR") == 0 || strcmp(buffer, "gga") == 0 || strcmp(buffer, "GGA") == 0){
			printf("G");
		} if(strcmp(buffer, "ggg") == 0 || strcmp(buffer, "GGG") == 0){
			printf("G");
		} else{
			printf(" ");
		}
	}
	printf("\n");
}


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 xors(char* string1, char* string2){
	int j = strlen(string2);
	int k = 0;
	char* i;

	for(i=string1; *i; i++){
		if(k >= j){
			k = 0;
		}
	        if(*i == '0' && string2[k] == '0'){
        	        *i = '0';
                } else if(*i == '0' && string2[k] == '1'){
                        *i = '1';
                } else if(*i == '1' && string2[k] == '0'){
                        *i = '1';
                } else if(*i == '1' && string2[k] == '1'){
                        *i = '0';
                }
		k++;
	}
}

This is the input data I used (Maybe it doesn't match your data?)

Code:

0yp1yg1yg0og1yp1op0yg1op1yg0yg1op0yg0op0og1yp0op1op1op0yg1yg10g0yg1op1op0yp0yg1yp1yp
1yg1yp0yp1yp1op1yp1og1op0op1yg1og0op1og1yg0yg1yg1op1og1op1op0yg0yp1yg0yg
1og0yg0og0yg1op1op1og0yg0yp0yp1yg0op1op1op0yg1yg1yg1op1yp1og0og1og1op1og1op1og0yp1og1yg1op1op1op0yp
0yp1og1op1og0og0yg1og1yg0yg1op1op0yp1yg
1op0yg1og1yp0yg1og1og0yp
1og0op0yp0yp1op0op1yp1yp0yp1op1og1op1op1yg0yg0yg
1og0op1yp0yp0yp0yp1op1yg1op1og0og0yp
1og0yp1op1og0yp0yp1yg1op1og0og0yp1og1op0og1yp1yg0og0yg

And the command I used was:

./debacon -f data -B -a b -x 011010 -v

-f specifies the data file
-B tells it to run a bacon cypher
-a b tells it to run bacon v2 cypher
-x 011010 tells it to xor 011010 with the bitstring the whole way through before debacon
-v turns on verbose mode

See following post for output...

[kn0w0n3]

Here is the first chunk of output, so you can see how it works:

Code:

Turning on Verbose Mode...
line 0 is: 0yp1yg1yg0og1yp1op0yg1op1yg0yg1op0yg0op0og1yp0op1op1op0yg1yg10g0yg1op1op0yp0yg1yp1yp

line 1 is: 1yg1yp0yp1yp1op1yp1og1op0op1yg1og0op1og1yg0yg1yg1op1og1op1op0yg0yp1yg0yg

line 2 is: 1og0yg0og0yg1op1op1og0yg0yp0yp1yg0op1op1op0yg1yg1yg1op1yp1og0og1og1op1og1op1og0yp1og1yg1op1op1op0yp

line 3 is: 0yp1og1op1og0og0yg1og1yg0yg1op1op0yp1yg

line 4 is: 1op0yg1og1yp0yg1og1og0yp

line 5 is: 1og0op0yp0yp1op0op1yp1yp0yp1op1og1op1op1yg0yg0yg

line 6 is: 1og0op1yp0yp0yp0yp1op1yg1op1og0og0yp

line 7 is: 1og0yp1op1og0yp0yp1yg1op1og0og0yp1og1op0og1yp1yg0og0yg

Total Characters Read: 456

Normalizeing line 0
Line 0 is now: 010111111001110100011100111011100011000001110000100100011111101011100100010011110110
Normalizeing line 1
Line 1 is now: 111110010110100110101100000111101000101111011111100101100100011010111011
Normalizeing line 2
Line 2 is now: 101011001011100100101011010010111000100100011111111100110101001101100101100101010101111100100100010
Normalizeing line 3
Line 3 is now: 010101100101001011101111011100100010111
Normalizeing line 4
Line 4 is now: 100011101110011101101010
Normalizeing line 5
Line 5 is now: 101000010010100000110110010100101100100111011011
Normalizeing line 6
Line 6 is now: 101000110010010010100111100101001010
Normalizeing line 7
Line 7 is now: 101010100101010010111100101001010101100001110111001011

Combined String: 010111111001110100011100111011100011000001110000100100011111101011100100010011110110111110010110100110101100000111101000101111011111100101100100011010111011101011001011100100101011010010111000100100011111111100110101001101100101100101010101111100100100010010101100101001011101111011100100010111100011101110011101101010101000010010100000110110010100101100100111011011101000110010010010100111100101001010101010100101010010111100101001010101100001110111001011
XORING with 011010
Resulting string 001101100011101110000110100001111001011011101010111110000101110001111110001001101100100100001100111100110110011101110010110101000101111111111110000000100001110001010001111110110001001000100010111110000101100110101111010111111111111111001111100110111110001000110110110011000111100001111110001101111001110100000111110000110010001000111010101100001110110110111101000001110010101000001000111101111111010000110000111111001000100110110011001111111011101101010001

String split into 5's for decoding:
00110 11000 11101 11000 01101 00001 11100 10110 11101 01011 11100 00101 11000 11111 10001 00110 11001 00100 00110 01111 00110 11001 11011 10010 11010 10001 01111 11111 11100 00000 10000 11100 01010 00111 11101 10001 00100 01000 10111 11000 01011 00110 10111 10101 11111 11111 11110 01111 10011 01111 10001 00011 01101 10011 00011 11000 01111 11000 11011 11001 11010 00001 11110 00011 00100 01000 11101 01011 00001 11011 01101 11101 00000 11100 10101 00000 10001 11101 11111 10100 00110 00011 11110 01000 10011 01100 11001 11111 10111 01101 01000 1

Debaconing:
GY YNB W L FY RGZEGPGZ S RP  AQ KH REIXYLGXV   PTPRDNTDYPY Z B DEI LB N A VAR  UGD ITMZ XNI 

Removing Spaces

001101100011101110000110100001111001011011101010111110000101110001111110001001101100100100001100111100110110011101110010110101000101111111111110000000100001110001010001111110110001001000100010111110000101100110101111010111111111111111001111100110111110001000110110110011000111100001111110001101111001110100000111110000110010001000111010101100001110110110111101000001110010101000001000111101111111010000110000111111001000100110110011001111111011101101010001

Shifting String
Buffer: 
001101100011101110000110100001111001011011101010111110000101110001111110001001101100100100001100111100110110011101110010110101000101111111111110000000100001110001010001111110110001001000100010111110000101100110101111010111111111111111001111100110111110001000110110110011000111100001111110001101111001110100000111110000110010001000111010101100001110110110111101000001110010101000001000111101111111010000110000111111001000100110110011001111111011101101010001

011011000111011100001101000011110010110111010101111100001011100011111100010011011001001000011001111001101100111011100101101010001011111111111100000001000011100010100011111101100010010001000101111100001011001101011110101111111111111110011111001101111100010001101101100110001111000011111100011011110011101000001111100001100100010001110101011000011101101101111010000011100101010000010001111011111110100001100001111110010001001101100110011111110111011010100010

String split into 5's for decoding:
01101 10001 11011 10000 11010 00011 11001 01101 11010 10111 11000 01011 10001 11111 00010 01101 10010 01000 01100 11110 01101 10011 10111 00101 10101 00010 11111 11111 11000 00001 00001 11000 10100 01111 11011 00010 01000 10001 01111 10000 10110 01101 01111 01011 11111 11111 11100 11111 00110 11111 00010 00110 11011 00110 00111 10000 11111 10001 10111 10011 10100 00011 11100 00110 01000 10001 11010 10110 00011 10110 11011 11010 00001 11001 01010 00001 00011 11011 11111 01000 01100 00111 11100 10001 00110 11001 10011 11111 01110 11010 10001 0

Debaconing:
NR Q DZN XYLR CNSIM NTXFVC  YBBYUP CIRPQWNPL    G CG GHQ RXTUD GIR WDW  BZKBD  IMH RGZT O R 

EDIT: It is also important to note that the trial I posted above used 1 for yellow, 0 for orange, 1 for green, and 0 for purple. (You can change this by specifying -n [0 or 1 or 2 or 3] I ran it with the other possibilities as well and still didn't get your result.

[bug.lady]

I've got a theory I've been working on for a couple of days. It almost feels like a Eureka moment with no payoff *yet. I'm wondering if anyone else wants to help me see if I'm on the right track or if I'm close but got off somewhere. I really feel like I'm on to something here(...)

I like your theory very much. Finally thanks to your concepts we are somehow getting the leaves to play a role in decyphering the private key. A few observations from my side that hopefully you (we ?) will be able to incorporate too

1. why read one feature per flame, changing features? My impression would be to read all 3 features from each flame, but stick to your interpretation that the leaves would indicate the order of features and what value should be considered as 1.
2. why don't you consider thickness (blob)? There are two more leaves in the upper segment, one is touching a very thin colorless flame and the other is present in the upper segment only in a small part, and that second one is indicating a nice thick short flame. Either of them can indicate thickness (blob).

 

[colonel_koval]

@Itod, so in your opinion the "The_____iskeyfile" message is the intended message?

Well, I have a theory didn't want to mention before while trying to find the proof. The message "THEfm_aurISKEYFILE" can hardly be a collision, and the bold scrambled part is intentionally left there to be de-scrambled in the same way other bit-streams should be de-scrambled to get a key. If you come across the stream of bytes from private key you may not notice something is scrambled, but if you find something like plaintext quoted above it's pretty obvious something is wrong. So to answer you: yes I think it's intentionally left there scrambled/corrupted to show the way.

Anything can be the way to de-scramble it in a coherent message. The current path I'm working are the chessboard fields affected by Phoenix fire. It looks to me that those chessboard fields that should be dark are somehow lighter with this bright blue Phoenix color then the white ones, so some bits associated with those chessboard fields should be inverted in raw bit-streams. I believe if we invert some bits from the "THEfm_aurISKEYFILE" bit-stream, in this way I've described, we will get coherent message from this bit-stream, and then we should apply this same transformation to colors bit-streams to get the private key.

AUR makes me think of Arch User Repository. Maybe there is a package in there that has some information?

Was there more than just this string in the output?

I am sceptical to the whole idea of it being the intended message, but still - to be on the safe side I entertained this idea for a while and thought that if we were looking for a file then maybe the fm.aur was the name of the file. I googled some results but nothing very constructive, though. But maybe somebody else will be more lucky.

[feedo]

I found this message in the flames:

" I AM COIN-ARTIST, I WANT TO TROLL YOU AND FUCK EVERY SINGLE NEURON CELL IN YOUR STUPID BRAIN"

[chubbychew]

@chubbychew, I have updated my code (posted below) so that it can xor bitstrings. That said, I did not find your string "AEIEMHAZYGPBBLMHJCSIQXADYMOZ "

kn0w0n3: Thanks so much for your help, I really appreciate the effort to get me up to speed on the coding. I figured out my errors eventually(bacon with 6bits vs 5bits). We were using different inputs and methods though. I was suggesting construction like this:

first 12 flames (space delimited flames) = 0yp 1yg 1yg 0og 1yp 1op 0yg 1op 1yg 0yg 1op 0yg

and taking one bit per flame on a rotation of height (1) outside color (y) and inside color (o)

first 12 flames after operation = 0 y g 0 y p 0 o g 0 o g       which gives 011010001001 according to my scheme

xor of that is of course '000000010011'

My point was that if you followed this pattern around the path you'd always get 0xxxxx0xxxxx0xxxxx0xxxxx (before xoring) which would suggest that constant 0 in front of every 6 bits could be a delimiter. So I was breaking into 6s then throwing out the leading zero and debaconing on the remaining 5 bits.

Code:

0yg0yp0og0og0op0op0yg0op0yp1
yp0yp1op0yg0og0yp1op0yg0
og0yp1og0yg0op0yg1yg0op1og0og1op0
yg1og0og0op0y
p0op0og0
op0yp0yp0og1og0y
g0yp0yp1og0y
g0og0yg1og0op0yg0y

Bacon on the 6s throwaway the leading zero
Doing that now I get->  JAYWUZUZVY.....
and after xoring -> AT_CMODODPCF.....

Bacon on the 5s keeping the zero
Doing this I now get -> NCIBQWK....
after xoring -> AE_IEMHAZY...

[massl]

Just for some diversion from the flames:

https://imgur.com/bNjFUzH

CSI 6 E 18 At Est <> 16

She is wearing those red filter glasses and using black light to check for evidence on clothes around minute 16.

There is more text hidden in the flame area (background of flames and flames) but it is very difficult to read.

[kn0w0n3]

We were using different inputs and methods though. I was suggesting construction like this:

first 12 flames (space delimited flames) = 0yp 1yg 1yg 0og 1yp 1op 0yg 1op 1yg 0yg 1op 0yg

and taking one bit per flame on a rotation of height (1) outside color (y) and inside color (o)

first 12 flames after operation = 0 y g 0 y p 0 o g 0 o g       which gives 011010001001 according to my scheme

xor of that is of course '000000010011'

....

....

Bacon on the 6s throwaway the leading zero
Doing that now I get->  JAYWUZUZVY.....
and after xoring -> AT_CMODODPCF.....

Bacon on the 5s keeping the zero
Doing this I now get -> NCIBQWK....
after xoring -> AE_IEMHAZY...

Interesting way of taking the data, but I can confirm you are at least doing your debaconing correctly now.

Here is my codes output using your input data

Code:

Turning on Verbose Mode...
line 0 is: 0yg0yp0og0og0op0op0yg0op0yp1

line 1 is: yp0yp1op0yg0og0yp1op0yg0

line 2 is: og0yp1og0yg0op0yg1yg0op1og0og1op0

line 3 is: yg1og0og0op0y

line 4 is: p0op0og0

line 5 is: op0yp0yp0og1og0y

line 6 is: g0yp0yp1og0y

line 7 is: g0og0yg1og0op0yg0y

Total Characters Read: 152

Normalizeing line 0
Line 0 is now: 0110100010010000000110000101
Normalizeing line 1
Line 1 is now: 100101000110010101000110
Normalizeing line 2
Line 2 is now: 010101010110000111110001010011000
Normalizeing line 3
Line 3 is now: 1110100100001
Normalizeing line 4
Line 4 is now: 00000010
Normalizeing line 5
Line 5 is now: 0001001000110101
Normalizeing line 6
Line 6 is now: 101001010101
Normalizeing line 7
Line 7 is now: 100101110100001101

Combined String: 01101000100100000001100001011001010001100101010001100101010101100001111100010100110001110100100001000000100001001000110101101001010101100101110100001101
XORING with 011010
Resulting string 00000001001101101000001000110000111000001100111000001100111100001000010101111101011000011101001000101001001000100001011100000000111100001100011101100100

String split into 5's for decoding:
00000 00100 11011 01000 00100 01100 00111 00000 11001 11000 00110 01111 00001 00001 01011 11101 01100 00111 01001 00010 10010 01000 10000 10111 00000 00011 11000 01100 01110 11001 00

Debaconing:
AE IEMHAZYGPBBL MHJCSIQXADYMOZ 

Removing Spaces

00000001001101101000001000110000111000001100111000001100111100001000010101111101011000011101001000101001001000100001011100000000111100001100011101100100

Shifting String
Buffer: 
00000001001101101000001000110000111000001100111000001100111100001000010101111101011000011101001000101001001000100001011100000000111100001100011101100100

00000010011011010000010001100001110000011001110000011001111000010000101011111010110000111010010001010010010001000010111000000001111000011000111011001000

String split into 5's for decoding:
00000 01001 10110 10000 01000 11000 01110 00001 10011 10000 01100 11110 00010 00010 10111 11010 11000 01110 10010 00101 00100 10001 00001 01110 00000 00111 10000 11000 11101 10010 00

Debaconing:
AJWQIYOBTQM CCX YOSFERBOAHQY S 

And some partial output without verbose...

AE IEMHAZYGPBBL MHJCSIQXADYMOZ
AJWQIYOBTQM CCX YOSFERBOAHQY S
ATNARQ DHAZ EFPVQ EKJCC APBR E
BG BDBYGOBTYIK LB IUSEFYA DDWI
CNUCGDQM DHQQV WDURJEILQB GHMQ
E IEMHAZYGPBBL MHJCSIQXADYMOZA
JWQIYOBTQM CCX YOSFERBOAHQY SA
TNARQ DHAZ EFPVQ EKJCC APBR EA
G BDBYGOBTYIK LB IUSEFYA DDWIA
NUCGDQM DHQQV WDURJEILQB GHMQA
 IEMHAZYGPBBL MHJCSIQXADYMOZAB
WQIYOBTQM CCX YOSFERBOAHQY SAC
NARQ DHAZ EFPVQ EKJCC APBR EAE

[mbitm]

https://prnt.sc/i1vr9d 

hand: https://prnt.sc/i1vpoi

key: https://prnt.sc/i1vqam

[feedo]

One can notice that every long red ribbon in the key has double tooth on top which could mean that the short flames hold only one bit of data whereas long flames hold two bits.

Just a notice for flames fuckers 

[feedo]

https://prnt.sc/i1vr9d 

hand: https://prnt.sc/i1vpoi

key: https://prnt.sc/i1vqam

Good job, but try to find something more interesting as I believe that coin-artist is a big troll and she can draw million of useless shits inside that painting which I believe that it is the most stupid puzzle in history.

[William1978]

The fact that the bitcoin address is a vanity one tells us the bits are random, so I guess reading them in a certain order is not possible. So that route is dead.
But CoinArtist also pointed to the poem a few times on twitter. But I couldn't get anything out of it, so I stopped looking at the text.

[bug.lady]

The fact that the bitcoin address is a vanity one tells us the bits are random, so I guess reading them in a certain order is not possible. So that route is dead.
But CoinArtist also pointed to the poem a few times on twitter. But I couldn't get anything out of it, so I stopped looking at the text.

No, you are mistaken, at least partly. You would have known that if you took the pain to read through the whole thread. As far as I know no commercial or publicly available software allows for creating vanity addresses with vanity private keys, but crax0r showed us (with examples) that you can implement it yourself and fix parts of both the public address and private key and successfuly generate matching pairs of private key and address.

for one thing it seems unlikely they would have mined minikeys for a vanity address...is there even vanity software that comes stock with that functionality?

Well, just because there is no off-the-shelf software to do something, doesn't mean its not doable:

Code:

SUPER1FLAMEN6QPEGRLTFZXDEAFFAL -> 1FLANSqJppAGxWdCrUW2VsrncH1NfWtNXo 
SUPER1FLAMEN6JQWSXAAHLJQJDEZXR -> 1FLArjwv7oPTZGUuGxLhEtPh7pkfoSbRTX 
SUPER1FLAMEN6RHJSDXWSCEFMSBMWX -> 1FLA4LzZtRuaV914mEJHaWmBGdaMt2AmRG 

These are all valid mini-private keys that I vanitized in 2 minutes, on GPU it would be much faster...

[hodld0r]

jeez you guys are way too hung up on all that.  and all i said was it seems less likely they would do all that.  sure you could take the name of your pet gerbil and hash it a quintillion times and maybe end up with shakespeare, like a room full of monkeys given infinity to jerk around on a typewriter.  of course you would then need to encode instructions on all these irregularly sized things and the steps and number of times to hash them and all that in the painting.  again, it simply seems less likely.  not impossible