FT8 Encoding test script

crc14.c

/**
 * \file
 * Functions and types for CRC checks.
 *
 * Generated on Thu Dec  6 17:52:34 2018
 * by pycrc v0.9.1, https://pycrc.org
 * using the configuration:
 *  - Width         = 14
 *  - Poly          = 0x2757
 *  - XorIn         = Undefined
 *  - ReflectIn     = Undefined
 *  - XorOut        = Undefined
 *  - ReflectOut    = Undefined
 *  - Algorithm     = bit-by-bit
 */
#include "crc14.h"     /* include the header file generated with pycrc */
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

static crc_t crc_reflect(crc_t data, size_t data_len);



crc_t crc_reflect(crc_t data, size_t data_len)
{
    unsigned int i;
    crc_t ret;

    ret = data & 0x01;
    for (i = 1; i < data_len; i++) {
        data >>= 1;
        ret = (ret << 1) | (data & 0x01);
    }
    return ret;
}


crc_t crc_init(const crc_cfg_t *cfg)
{
    unsigned int i;
    bool bit;
    crc_t crc = cfg->xor_in;
    for (i = 0; i < 14; i++) {
        bit = crc & 0x01;
        if (bit) {
            crc = ((crc ^ 0x2757) >> 1) | 0x2000;
        } else {
            crc >>= 1;
        }
    }
    return crc & 0x3fff;
}


crc_t crc_update(const crc_cfg_t *cfg, crc_t crc, const void *data, size_t data_len)
{
    const unsigned char *d = (const unsigned char *)data;
    unsigned int i;
    bool bit;
    unsigned char c;

    while (data_len--) {
        if (cfg->reflect_in) {
            c = crc_reflect(*d++, 8);
        } else {
            c = *d++;
        }
        for (i = 0; i < 8; i++) {
            bit = crc & 0x2000;
            crc = (crc << 1) | ((c >> (7 - i)) & 0x01);
            if (bit) {
                crc ^= 0x2757;
            }
        }
        crc &= 0x3fff;
    }
    return crc & 0x3fff;
}


crc_t crc_finalize(const crc_cfg_t *cfg, crc_t crc)
{
    unsigned int i;
    bool bit;

    for (i = 0; i < 14; i++) {
        bit = crc & 0x2000;
        crc <<= 1;
        if (bit) {
            crc ^= 0x2757;
        }
    }
    if (cfg->reflect_out) {
        crc = crc_reflect(crc, 14);
    }
    return (crc ^ cfg->xor_out) & 0x3fff;
}

crc14.h

/**
 * \file
 * Functions and types for CRC checks.
 *
 * Generated on Thu Dec  6 17:52:01 2018
 * by pycrc v0.9.1, https://pycrc.org
 * using the configuration:
 *  - Width         = 14
 *  - Poly          = 0x2757
 *  - XorIn         = Undefined
 *  - ReflectIn     = Undefined
 *  - XorOut        = Undefined
 *  - ReflectOut    = Undefined
 *  - Algorithm     = bit-by-bit
 *
 * This file defines the functions crc_init(), crc_update() and crc_finalize().
 *
 * The crc_init() function returns the inital \c crc value and must be called
 * before the first call to crc_update().
 * Similarly, the crc_finalize() function must be called after the last call
 * to crc_update(), before the \c crc is being used.
 * is being used.
 *
 * The crc_update() function can be called any number of times (including zero
 * times) in between the crc_init() and crc_finalize() calls.
 *
 * This pseudo-code shows an example usage of the API:
 * \code{.c}
 * crc_cfg_t cfg = {
 *     0,      // reflect_in
 *     0,      // xor_in
 *     0,      // reflect_out
 *     0,      // xor_out
 * };
 * crc_t crc;
 * unsigned char data[MAX_DATA_LEN];
 * size_t data_len;
 *
 * crc = crc_init(&cfg);
 * while ((data_len = read_data(data, MAX_DATA_LEN)) > 0) {
 *     crc = crc_update(&cfg, crc, data, data_len);
 * }
 * crc = crc_finalize(&cfg, crc);
 * \endcode
 */
#ifndef CRC14_H
#define CRC14_H

#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif


/**
 * The definition of the used algorithm.
 *
 * This is not used anywhere in the generated code, but it may be used by the
 * application code to call algorithm-specific code, if desired.
 */
#define CRC_ALGO_BIT_BY_BIT 1


/**
 * The type of the CRC values.
 *
 * This type must be big enough to contain at least 14 bits.
 */
typedef uint_fast16_t crc_t;


/**
 * The configuration type of the CRC algorithm.
 */
typedef struct {
    bool reflect_in;            /*!< Whether the input shall be reflected or not */
    crc_t xor_in;               /*!< The initial value of the register */
    bool reflect_out;           /*!< Whether the output shall be reflected or not */
    crc_t xor_out;              /*!< The value which shall be XOR-ed to the final CRC value */
} crc_cfg_t;


/**
 * Calculate the initial crc value.
 *
 * \param[in] cfg  A pointer to an initialised crc_cfg_t structure.
 * \return     The initial crc value.
 */
crc_t crc_init(const crc_cfg_t *cfg);


/**
 * Update the crc value with new data.
 *
 * \param[in] crc      The current crc value.
 * \param[in] cfg      A pointer to an initialised crc_cfg_t structure.
 * \param[in] data     Pointer to a buffer of \a data_len bytes.
 * \param[in] data_len Number of bytes in the \a data buffer.
 * \return             The updated crc value.
 */
crc_t crc_update(const crc_cfg_t *cfg, crc_t crc, const void *data, size_t data_len);


/**
 * Calculate the final crc value.
 *
 * \param[in] cfg  A pointer to an initialised crc_cfg_t structure.
 * \param[in] crc  The current crc value.
 * \return     The final crc value.
 */
crc_t crc_finalize(const crc_cfg_t *cfg, crc_t crc);


#ifdef __cplusplus
}           /* closing brace for extern "C" */
#endif

#endif      /* CRC14_H */

ft8_encode.cpp

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <ctype.h>

#include "crc14.h"
#include "generator.h"

#define FT8_BIT_COUNT		174
#define FT8_ENCODE_COUNT	79

int8_t hex2int(char ch)
{
    if (ch >= '0' && ch <= '9')
        return ch - '0';
    if (ch >= 'A' && ch <= 'F')
        return ch - 'A' + 10;
    if (ch >= 'a' && ch <= 'f')
        return ch - 'a' + 10;
    return -1;
}

uint8_t ft_code(char c)
{
	/* Validate the input then return the proper integer code */
	// Return 255 as an error code if the char is not allowed

	if(isdigit(c))
	{
		return (uint8_t)(c) - 47;
	}
	else if(c >= 'A' && c <= 'Z')
	{
		return (uint8_t)(c) - 54;
	}
	else if(c == ' ')
	{
		return 0;
	}
	else if(c == '+')
	{
		return 38;
	}
	else if(c == '-')
	{
		return 39;
	}
	else if(c == '.')
	{
		return 40;
	}
	else if(c == '/')
	{
		return 41;
	}
	else if(c == '?')
	{
		return 42;
	}
	else
	{
		return 255;
	}
}

void ft_message_prep(char * message)
{
  uint8_t i;
  char temp_msg[14];

  snprintf(temp_msg, 14, "%*s", 13, message);

  // Convert all chars to uppercase
  for(i = 0; i < 13; i++)
  {
    if(islower(temp_msg[i]))
    {
      temp_msg[i] = toupper(temp_msg[i]);
    }
  }

  strcpy(message, temp_msg);
}

void ft8_bit_packing(char* message, uint8_t* codeword)
{
	// Just encoding type 0 free text and type 0.5 telemetry for now

	// The bit packing algorithm is:
	// sum(message(pos) * 42^pos)

	uint8_t i3 = 0;
	uint8_t n3 = 0;
	uint8_t qa[10];
	uint8_t qb[10];
	char c18[19];
	bool telem = false;
	char temp_msg[19];
	memset(qa, 0, 10);
	memset(qb, 0, 10);

	uint8_t i, j, x, i0;
	uint32_t ireg = 0;

	// See if this is a telemetry message
	// Has to be hex digits, can be no more than 18
	for(i = 0; i < 19; ++i)
	{
		if(message[i] == 0 || message[i] == ' ')
		{
			break;
		}
		else if(hex2int(message[i]) == -1)
		{
			telem = false;
			break;
		}
		else
		{
			c18[i] = message[i];
			telem = true;
		}
	}

	// If telemetry
	if(telem)
	{
		// Get the first 18 hex digits
		for(i = 0; i < strlen(message); ++i)
		{
			i0 = i;
			if(message[i] == ' ')
			{
				--i0;
				break;
			}
		}

		memset(c18, 0, 19);
		memmove(c18, message, i0 + 1);
		snprintf(temp_msg, 19, "%*s", 18, c18);

		// Convert all chars to uppercase
	    for(i = 0; i < strlen(temp_msg); i++)
	    {
	      if(islower(temp_msg[i]))
	      {
	        temp_msg[i] = toupper(temp_msg[i]);
	      }
	    }
		strcpy(message, temp_msg);
		printf("Telemetry Message:\n%s\n\n", message);


		uint8_t temp_int;
		temp_int = message[0] == ' ' ? 0 : hex2int(message[0]);
		for(i = 1; i < 4; ++i)
		{
			codeword[i - 1] = (((temp_int << i) & 0x8) >> 3) & 1;
			// printf("%u\n", i - 1);
		}
		temp_int = message[1] == ' ' ? 0 : hex2int(message[1]);
		for(i = 0; i < 4; ++i)
		{
			codeword[i + 3] = (((temp_int << i) & 0x8) >> 3) & 1;
			// printf("%u\n", i + 3);
		}
		for(i = 0; i < 8; ++i)
		{
			if(message[2 * i + 2] == ' ')
			{
				temp_int = 0;
			}
			else
			{
				temp_int = hex2int(message[2 * i + 2]);
			}
			// printf("%u     %u\n", 2 * i + 2, temp_int);
			// temp_int = message[2 * i + 2] == ' ' ? 0 : hex2int(message[2 * i + 2]);
			for(j = 0; j < 4; ++j)
			{
				codeword[(i + 1) * 8 + j - 1] = (((temp_int << j) & 0x8) >> 3) & 1;
				// printf("%u\n", codeword[(i + 1) * 8 + j - 1]);
			}
			if(message[2 * i + 3] == ' ')
			{
				temp_int = 0;
			}
			else
			{
				temp_int = hex2int(message[2 * i + 3]);
			}
			// printf("%u     %u\n", 2 * i + 3, temp_int);
			// temp_int = message[2 * i + 3] == ' ' ? 0 : hex2int(message[2 * i + 3]);
			for(j = 0; j < 4; ++j)
			{
				codeword[(i + 1) * 8 + j + 3] = (((temp_int << j) & 0x8) >> 3) & 1;
				// printf("%u\n", codeword[(i + 1) * 8 + j + 3]);
			}
		}

		i3 = 0;
		n3 = 5;
	}
	else
	{
		ft_message_prep(message);
		printf("Message:\n%s\n\n", message);

		for(i = 0; i < 13; ++i)
		{
			x = ft_code(message[i]);

			// mult
			ireg = 0;
			for(j = 0; j < 9; ++j)
			{
				ireg = (uint8_t)qa[j] * 42 + (uint8_t)((ireg >> 8) & 0xff);
				qb[j] = (uint8_t)(ireg & 0xff);
			}
			qb[9] = (uint8_t)((ireg >> 8) & 0xff);

			// add
			ireg = x << 8;
			for(j = 0; j < 9; ++j)
			{
				ireg = (uint8_t)qb[j] + (uint8_t)((ireg >> 8) & 0xff);
				qa[j] = (uint8_t)(ireg & 0xff);
			}
			qa[9] = (uint8_t)((ireg >> 8) & 0xff);
		}

		// Format bits to output array
		for(i = 1; i < 8; ++i)
		{
			codeword[i - 1] = (((qa[8] << i) & 0x80) >> 7) & 1;
		}
		for(i = 0; i < 8; ++i)
		{
			for(j = 0; j < 8; ++j)
			{
				codeword[(i + 1) * 8 + j - 1] = (((qa[7 - i] << j) & 0x80) >> 7) & 1;
			}
		}
	}

	// Write the message type bits at the end of the array
	for(i = 0; i < 3; ++i)
	{
		codeword[i + 71] = (n3 >> i) & 1;
	}
	for(i = 0; i < 3; ++i)
	{
		codeword[i + 74] = (i3 >> i) & 1;
	}
}

void ft8_encode(uint8_t* codeword, uint8_t* symbols)
{
	const uint8_t FT8_N = 174;
	const uint8_t FT8_K = 91;
	const uint8_t FT8_M = FT8_N - FT8_K;

	uint8_t tempchar[FT8_K];
	uint8_t message91[FT8_K];
	uint8_t pchecks[FT8_M];
	uint8_t i1_msg_bytes[12];
	uint8_t i, j;
	uint16_t ncrc14;

	crc_t crc;
	crc_cfg_t crc_cfg;
	crc_cfg.reflect_in = 0;
	crc_cfg.xor_in = 0;
	crc_cfg.reflect_out = 0;
	crc_cfg.xor_out = 0;
	crc = crc_init(&crc_cfg);

	// Add 14-bit CRC to form 91-bit message
	memset(tempchar, 0, 91);
	memcpy(tempchar, codeword, 77);
	tempchar[77] = 0;
	tempchar[78] = 0;
	tempchar[79] = 0;
	memset(i1_msg_bytes, 0, 12);
	for(i = 0; i < 10; ++i)
	{
		for(j = 0; j < 8; ++j)
		{
			i1_msg_bytes[i] <<= 1;
			i1_msg_bytes[i] |= tempchar[i * 8 + j];
		}
	}

	ncrc14 = crc_update(&crc_cfg, crc, (unsigned char *)i1_msg_bytes, 12);
	crc = crc_finalize(&crc_cfg, crc);

	for(i = 0; i < 14; ++i)
	{
		if((((ncrc14 << (i + 2)) & 0x8000) >> 15) & 1)
		{
			tempchar[i + 77] = 1;
		}
		else
		{
			tempchar[i + 77] = 0;
		}
	}
	memcpy(message91, tempchar, 91);

	for(i = 0; i < FT8_M; ++i)
	{
		uint32_t nsum = 0;
		for(j = 0; j < FT8_K; ++j)
		{
			uint8_t bits = generator_bits[i][j / 8];
			bits <<= (j % 8);
			bits &= 0x80;
			bits >>= 7;
			bits &= 1;
			nsum += (message91[j] * bits);
		}
		pchecks[i] = nsum % 2;
	}

	memcpy(symbols, message91, FT8_K);
	memcpy(symbols + FT8_K, pchecks, FT8_M);
}

void ft8_merge_sync_vector(uint8_t* symbols, uint8_t* output)
{
	const uint8_t costas7x7[7] = {3, 1, 4, 0, 6, 5, 2};
	const uint8_t graymap[8] = {0, 1, 3, 2, 5, 6, 4, 7};
	uint8_t i, j, k, idx;

	// Insert Costas sync arrays
	memcpy(output, costas7x7, 7);
	memcpy(output + 36, costas7x7, 7);
	memcpy(output + FT8_ENCODE_COUNT - 7, costas7x7, 7);

	k = 6;
	for(j = 0; j < 58; ++j) // 58 data symbols
	{
		i = 3 * j;
		++k;
		if(j == 29)
		{
			k += 7;
		}
		idx = symbols[i] * 4 + symbols[i + 1] * 2 + symbols[i + 2];
		output[k] = graymap[idx];
	}
}

int main(int argc, char *argv[])
{
	uint8_t i;

	char message[20];
	strcpy(message, argv[1]);

 	// char message[14] = "NT7S CN85";
	// char message[14] = "ABCDEFGHIJKLM";

	// Ensure that the message text conforms to standards
	// --------------------------------------------------
	// ft_message_prep(message);

	// Print the message
	// printf("Message:\n%s\n\n", message);

	// Bit packing
	// -----------
	uint8_t c[77];
	memset(c, 0, 77);
	ft8_bit_packing(message, c);

	// Print the 77 1-bit symbols for debugging
	printf("Packed message, 1-bit symbols:\n");
	for(i = 0; i < 77; i++)
	{
		printf("%1u", c[i]);
	}
	printf("\n\n");

	// Message encoding
	uint8_t s[FT8_BIT_COUNT];
	ft8_encode(c, s);

	// Print the 174 codeword 1-bit symbols for debugging
	printf("Packed codeword, 1-bit symbols:\n");
	for(i = 0; i < FT8_BIT_COUNT; i++)
	{
		printf("%1u", s[i]);
	}
	printf("\n\n");

	uint8_t o[FT8_ENCODE_COUNT];
	ft8_merge_sync_vector(s, o);

	printf("%u Channel Symbols:\n", FT8_ENCODE_COUNT);
	for(i = 0; i < FT8_ENCODE_COUNT; i++)
	{
		printf("%1u", o[i]);
	}
	printf("\n\n");

	return 0;
}

generator.h

#ifndef GENERATOR_H
#define GENERATOR_H

#include <stdint.h>

const uint8_t generator_bits[83][12] =
{
    {0b10000011, 0b00101001, 0b11001110, 0b00010001, 0b10111111, 0b00110001, 0b11101010, 0b11110101, 0b00001001, 0b11110010, 0b01111111, 0b11000000},
    {0b01110110, 0b00011100, 0b00100110, 0b01001110, 0b00100101, 0b11000010, 0b01011001, 0b00110011, 0b01010100, 0b10010011, 0b00010011, 0b00100000},
    {0b11011100, 0b00100110, 0b01011001, 0b00000010, 0b11111011, 0b00100111, 0b01111100, 0b01100100, 0b00010000, 0b10100001, 0b10111101, 0b11000000},
    {0b00011011, 0b00111111, 0b01000001, 0b01111000, 0b01011000, 0b11001101, 0b00101101, 0b11010011, 0b00111110, 0b11000111, 0b11110110, 0b00100000},
    {0b00001001, 0b11111101, 0b10100100, 0b11111110, 0b11100000, 0b01000001, 0b10010101, 0b11111101, 0b00000011, 0b01000111, 0b10000011, 0b10100000},
    {0b00000111, 0b01111100, 0b11001100, 0b11000001, 0b00011011, 0b10001000, 0b01110011, 0b11101101, 0b01011100, 0b00111101, 0b01001000, 0b10100000},
    {0b00101001, 0b10110110, 0b00101010, 0b11111110, 0b00111100, 0b10100000, 0b00110110, 0b11110100, 0b11111110, 0b00011010, 0b10011101, 0b10100000},
    {0b01100000, 0b01010100, 0b11111010, 0b11110101, 0b11110011, 0b01011101, 0b10010110, 0b11010011, 0b10110000, 0b11001000, 0b11000011, 0b11100000},
    {0b11100010, 0b00000111, 0b10011000, 0b11100100, 0b00110001, 0b00001110, 0b11101101, 0b00100111, 0b10001000, 0b01001010, 0b11101001, 0b00000000},
    {0b01110111, 0b01011100, 0b10011100, 0b00001000, 0b11101000, 0b00001110, 0b00100110, 0b11011101, 0b10101110, 0b01010110, 0b00110001, 0b10000000},
    {0b10110000, 0b10111000, 0b00010001, 0b00000010, 0b10001100, 0b00101011, 0b11111001, 0b10010111, 0b00100001, 0b00110100, 0b10000111, 0b11000000},
    {0b00011000, 0b10100000, 0b11001001, 0b00100011, 0b00011111, 0b11000110, 0b00001010, 0b11011111, 0b01011100, 0b01011110, 0b10100011, 0b00100000},
    {0b01110110, 0b01000111, 0b00011110, 0b10000011, 0b00000010, 0b10100000, 0b01110010, 0b00011110, 0b00000001, 0b10110001, 0b00101011, 0b10000000},
    {0b11111111, 0b10111100, 0b11001011, 0b10000000, 0b11001010, 0b10000011, 0b01000001, 0b11111010, 0b11111011, 0b01000111, 0b10110010, 0b11100000},
    {0b01100110, 0b10100111, 0b00101010, 0b00010101, 0b10001111, 0b10010011, 0b00100101, 0b10100010, 0b10111111, 0b01100111, 0b00010111, 0b00000000},
    {0b11000100, 0b00100100, 0b00110110, 0b10001001, 0b11111110, 0b10000101, 0b10110001, 0b11000101, 0b00010011, 0b01100011, 0b10100001, 0b10000000},
    {0b00001101, 0b11111111, 0b01110011, 0b10010100, 0b00010100, 0b11010001, 0b10100001, 0b10110011, 0b01001011, 0b00011100, 0b00100111, 0b00000000},
    {0b00010101, 0b10110100, 0b10001000, 0b00110000, 0b01100011, 0b01101100, 0b10001011, 0b10011001, 0b10001001, 0b01001001, 0b01110010, 0b11100000},
    {0b00101001, 0b10101000, 0b10011100, 0b00001101, 0b00111101, 0b11101000, 0b00011101, 0b01100110, 0b01010100, 0b10001001, 0b10110000, 0b11100000},
    {0b01001111, 0b00010010, 0b01101111, 0b00110111, 0b11111010, 0b01010001, 0b11001011, 0b11100110, 0b00011011, 0b11010110, 0b10111001, 0b01000000},
    {0b10011001, 0b11000100, 0b01110010, 0b00111001, 0b11010000, 0b11011001, 0b01111101, 0b00111100, 0b10000100, 0b11100000, 0b10010100, 0b00000000},
    {0b00011001, 0b00011001, 0b10110111, 0b01010001, 0b00011001, 0b01110110, 0b01010110, 0b00100001, 0b10111011, 0b01001111, 0b00011110, 0b10000000},
    {0b00001001, 0b11011011, 0b00010010, 0b11010111, 0b00110001, 0b11111010, 0b11101110, 0b00001011, 0b10000110, 0b11011111, 0b01101011, 0b10000000},
    {0b01001000, 0b10001111, 0b11000011, 0b00111101, 0b11110100, 0b00111111, 0b10111101, 0b11101110, 0b10100100, 0b11101010, 0b11111011, 0b01000000},
    {0b10000010, 0b01110100, 0b00100011, 0b11101110, 0b01000000, 0b10110110, 0b01110101, 0b11110111, 0b01010110, 0b11101011, 0b01011111, 0b11100000},
    {0b10101011, 0b11100001, 0b10010111, 0b11000100, 0b10000100, 0b11001011, 0b01110100, 0b01110101, 0b01110001, 0b01000100, 0b10101001, 0b10100000},
    {0b00101011, 0b01010000, 0b00001110, 0b01001011, 0b11000000, 0b11101100, 0b01011010, 0b01101101, 0b00101011, 0b11011011, 0b11011101, 0b00000000},
    {0b11000100, 0b01110100, 0b10101010, 0b01010011, 0b11010111, 0b00000010, 0b00011000, 0b01110110, 0b00010110, 0b01101001, 0b00110110, 0b00000000},
    {0b10001110, 0b10111010, 0b00011010, 0b00010011, 0b11011011, 0b00110011, 0b10010000, 0b10111101, 0b01100111, 0b00011000, 0b11001110, 0b11000000},
    {0b01110101, 0b00111000, 0b01000100, 0b01100111, 0b00111010, 0b00100111, 0b01111000, 0b00101100, 0b11000100, 0b00100000, 0b00010010, 0b11100000},
    {0b00000110, 0b11111111, 0b10000011, 0b10100001, 0b01000101, 0b11000011, 0b01110000, 0b00110101, 0b10100101, 0b11000001, 0b00100110, 0b10000000},
    {0b00111011, 0b00110111, 0b01000001, 0b01111000, 0b01011000, 0b11001100, 0b00101101, 0b11010011, 0b00111110, 0b11000011, 0b11110110, 0b00100000},
    {0b10011010, 0b01001010, 0b01011010, 0b00101000, 0b11101110, 0b00010111, 0b11001010, 0b10011100, 0b00110010, 0b01001000, 0b01000010, 0b11000000},
    {0b10111100, 0b00101001, 0b11110100, 0b01100101, 0b00110000, 0b10011100, 0b10010111, 0b01111110, 0b10001001, 0b01100001, 0b00001010, 0b01000000},
    {0b00100110, 0b01100011, 0b10101110, 0b01101101, 0b11011111, 0b10001011, 0b01011100, 0b11100010, 0b10111011, 0b00101001, 0b01001000, 0b10000000},
    {0b01000110, 0b11110010, 0b00110001, 0b11101111, 0b11100100, 0b01010111, 0b00000011, 0b01001100, 0b00011000, 0b00010100, 0b01000001, 0b10000000},
    {0b00111111, 0b10110010, 0b11001110, 0b10000101, 0b10101011, 0b11101001, 0b10110000, 0b11000111, 0b00101110, 0b00000110, 0b11111011, 0b11100000},
    {0b11011110, 0b10000111, 0b01001000, 0b00011111, 0b00101000, 0b00101100, 0b00010101, 0b00111001, 0b01110001, 0b10100000, 0b10100010, 0b11100000},
    {0b11111100, 0b11010111, 0b11001100, 0b11110010, 0b00111100, 0b01101001, 0b11111010, 0b10011001, 0b10111011, 0b10100001, 0b01000001, 0b00100000},
    {0b11110000, 0b00100110, 0b00010100, 0b01000111, 0b11101001, 0b01001001, 0b00001100, 0b10101000, 0b11100100, 0b01110100, 0b11001110, 0b11000000},
    {0b01000100, 0b00010000, 0b00010001, 0b01011000, 0b00011000, 0b00011001, 0b01101111, 0b10010101, 0b11001101, 0b11010111, 0b00000001, 0b00100000},
    {0b00001000, 0b10001111, 0b11000011, 0b00011101, 0b11110100, 0b10111111, 0b10111101, 0b11100010, 0b10100100, 0b11101010, 0b11111011, 0b01000000},
    {0b10111000, 0b11111110, 0b11110001, 0b10110110, 0b00110000, 0b01110111, 0b00101001, 0b11111011, 0b00001010, 0b00000111, 0b10001100, 0b00000000},
    {0b01011010, 0b11111110, 0b10100111, 0b10101100, 0b11001100, 0b10110111, 0b01111011, 0b10111100, 0b10011101, 0b10011001, 0b10101001, 0b00000000},
    {0b01001001, 0b10100111, 0b00000001, 0b01101010, 0b11000110, 0b01010011, 0b11110110, 0b01011110, 0b11001101, 0b11001001, 0b00000111, 0b01100000},
    {0b00011001, 0b01000100, 0b11010000, 0b10000101, 0b10111110, 0b01001110, 0b01111101, 0b10101000, 0b11010110, 0b11001100, 0b01111101, 0b00000000},
    {0b00100101, 0b00011111, 0b01100010, 0b10101101, 0b11000100, 0b00000011, 0b00101111, 0b00001110, 0b11100111, 0b00010100, 0b00000000, 0b00100000},
    {0b01010110, 0b01000111, 0b00011111, 0b10000111, 0b00000010, 0b10100000, 0b01110010, 0b00011110, 0b00000000, 0b10110001, 0b00101011, 0b10000000},
    {0b00101011, 0b10001110, 0b01001001, 0b00100011, 0b11110010, 0b11011101, 0b01010001, 0b11100010, 0b11010101, 0b00110111, 0b11111010, 0b00000000},
    {0b01101011, 0b01010101, 0b00001010, 0b01000000, 0b10100110, 0b01101111, 0b01000111, 0b01010101, 0b11011110, 0b10010101, 0b11000010, 0b01100000},
    {0b10100001, 0b10001010, 0b11010010, 0b10001101, 0b01001110, 0b00100111, 0b11111110, 0b10010010, 0b10100100, 0b11110110, 0b11001000, 0b01000000},
    {0b00010000, 0b11000010, 0b11100101, 0b10000110, 0b00111000, 0b10001100, 0b10111000, 0b00101010, 0b00111101, 0b10000000, 0b01110101, 0b10000000},
    {0b11101111, 0b00110100, 0b10100100, 0b00011000, 0b00010111, 0b11101110, 0b00000010, 0b00010011, 0b00111101, 0b10110010, 0b11101011, 0b00000000},
    {0b01111110, 0b10011100, 0b00001100, 0b01010100, 0b00110010, 0b01011010, 0b10011100, 0b00010101, 0b10000011, 0b01101110, 0b00000000, 0b00000000},
    {0b00110110, 0b10010011, 0b11100101, 0b01110010, 0b11010001, 0b11111101, 0b11100100, 0b11001101, 0b11110000, 0b01111001, 0b11101000, 0b01100000},
    {0b10111111, 0b10110010, 0b11001110, 0b11000101, 0b10101011, 0b11100001, 0b10110000, 0b11000111, 0b00101110, 0b00000111, 0b11111011, 0b11100000},
    {0b01111110, 0b11100001, 0b10000010, 0b00110000, 0b11000101, 0b10000011, 0b11001100, 0b11001100, 0b01010111, 0b11010100, 0b10110000, 0b10000000},
    {0b10100000, 0b01100110, 0b11001011, 0b00101111, 0b11101101, 0b10101111, 0b11001001, 0b11110101, 0b00100110, 0b01100100, 0b00010010, 0b01100000},
    {0b10111011, 0b00100011, 0b01110010, 0b01011010, 0b10111100, 0b01000111, 0b11001100, 0b01011111, 0b01001100, 0b11000100, 0b11001101, 0b00100000},
    {0b11011110, 0b11011001, 0b11011011, 0b10100011, 0b10111110, 0b11100100, 0b00001100, 0b01011001, 0b10110101, 0b01100000, 0b10011011, 0b01000000},
    {0b11011001, 0b10100111, 0b00000001, 0b01101010, 0b11000110, 0b01010011, 0b11100110, 0b11011110, 0b11001101, 0b11001001, 0b00000011, 0b01100000},
    {0b10011010, 0b11010100, 0b01101010, 0b11101101, 0b01011111, 0b01110000, 0b01111111, 0b00101000, 0b00001010, 0b10110101, 0b11111100, 0b01000000},
    {0b11100101, 0b10010010, 0b00011100, 0b01110111, 0b10000010, 0b00100101, 0b10000111, 0b00110001, 0b01101101, 0b01111101, 0b00111100, 0b00100000},
    {0b01001111, 0b00010100, 0b11011010, 0b10000010, 0b01000010, 0b10101000, 0b10111000, 0b01101101, 0b11001010, 0b01110011, 0b00110101, 0b00100000},
    {0b10001011, 0b10001011, 0b01010000, 0b01111010, 0b11010100, 0b01100111, 0b11010100, 0b01000100, 0b00011101, 0b11110111, 0b01110000, 0b11100000},
    {0b00100010, 0b10000011, 0b00011100, 0b10011100, 0b11110001, 0b00010110, 0b10010100, 0b01100111, 0b10101101, 0b00000100, 0b10110110, 0b10000000},
    {0b00100001, 0b00111011, 0b10000011, 0b10001111, 0b11100010, 0b10101110, 0b01010100, 0b11000011, 0b10001110, 0b11100111, 0b00011000, 0b00000000},
    {0b01011101, 0b10010010, 0b01101011, 0b01101101, 0b11010111, 0b00011111, 0b00001000, 0b01010001, 0b10000001, 0b10100100, 0b11100001, 0b00100000},
    {0b01100110, 0b10101011, 0b01111001, 0b11010100, 0b10110010, 0b10011110, 0b11100110, 0b11100110, 0b10010101, 0b00001001, 0b11100101, 0b01100000},
    {0b10010101, 0b10000001, 0b01001000, 0b01101000, 0b00101101, 0b01110100, 0b10001010, 0b00111000, 0b11011101, 0b01101000, 0b10111010, 0b10100000},
    {0b10111000, 0b11001110, 0b00000010, 0b00001100, 0b11110000, 0b01101001, 0b11000011, 0b00101010, 0b01110010, 0b00111010, 0b10110001, 0b01000000},
    {0b11110100, 0b00110011, 0b00011101, 0b01101101, 0b01000110, 0b00010110, 0b00000111, 0b11101001, 0b01010111, 0b01010010, 0b01110100, 0b01100000},
    {0b01101101, 0b10100010, 0b00111011, 0b10100100, 0b00100100, 0b10111001, 0b01011001, 0b01100001, 0b00110011, 0b11001111, 0b10011100, 0b10000000},
    {0b10100110, 0b00110110, 0b10111100, 0b10111100, 0b01111011, 0b00110000, 0b11000101, 0b11111011, 0b11101010, 0b11100110, 0b01111111, 0b11100000},
    {0b01011100, 0b10110000, 0b11011000, 0b01101010, 0b00000111, 0b11011111, 0b01100101, 0b01001010, 0b10010000, 0b10001001, 0b10100010, 0b00000000},
    {0b11110001, 0b00011111, 0b00010000, 0b01101000, 0b01001000, 0b01111000, 0b00001111, 0b11001001, 0b11101100, 0b11011101, 0b10000000, 0b10100000},
    {0b00011111, 0b10111011, 0b01010011, 0b01100100, 0b11111011, 0b10001101, 0b00101100, 0b10011101, 0b01110011, 0b00001101, 0b01011011, 0b10100000},
    {0b11111100, 0b10111000, 0b01101011, 0b11000111, 0b00001010, 0b01010000, 0b11001001, 0b11010000, 0b00101010, 0b01011101, 0b00000011, 0b01000000},
    {0b10100101, 0b00110100, 0b01000011, 0b00110000, 0b00101001, 0b11101010, 0b11000001, 0b01011111, 0b00110010, 0b00101110, 0b00110100, 0b11000000},
    {0b11001001, 0b10001001, 0b11011001, 0b11000111, 0b11000011, 0b11010011, 0b10111000, 0b11000101, 0b01011101, 0b01110101, 0b00010011, 0b00000000},
    {0b01111011, 0b10110011, 0b10001011, 0b00101111, 0b00000001, 0b10000110, 0b11010100, 0b01100110, 0b01000011, 0b10101110, 0b10010110, 0b00100000},
    {0b00100110, 0b01000100, 0b11101011, 0b10101101, 0b11101011, 0b01000100, 0b10111001, 0b01000110, 0b01111101, 0b00011111, 0b01000010, 0b11000000},
    {0b01100000, 0b10001100, 0b11001000, 0b01010111, 0b01011001, 0b01001011, 0b11111011, 0b10110101, 0b01011101, 0b01101001, 0b01100000, 0b00000000}
};

#endif