• Source code for library project and top-level entry point:
  https://github.com/BlueAnt1/puzzle-coding
• Documentation:
  https://blueant1.github.io/puzzle-coding/documentation/puzzlecoding/
• Encoding formats reference:
  https://blueant1.github.io/puzzle-coding/documentation/puzzlecoding/encodingformats

• The address https://www.sudokuwiki.org/killersudoku.aspx?bd=
• 81 characters for the colours defining the shapes
• a comma
• 162 characters stating the clues, padded with zeros if necessary. Clues are the sums of the cages and appear once per cage in the top-left most position

• All puzzles need the ability to store progress - which consists of solved cells and candidates.
• Unlike Sudoku the Clue/solved cell difference is not needed. A single cell cage may be printed with a large number but it is still a cage clue.
• It will be very helpful to include a version header to give vital context for interpreting the data

• There can be up to five cage colours so 3 bits needed.
• In 9x9 Killer Sudoku the largest clue number will be 45 (all the numbers summed). 6 bits required to store this.
• In KenKen 6x6 there is hard cap of 999 for clue numbers (at least as I make them). We need 10 bits to store up to 1023. A clue larger than this will abort the encoding. Do send me examples in case they exist in the wild.
• We will continue to store progress in 10 bits to make it similar to the rest of the scheme. That means adding 9 to solved cells and 18 to candidates to get the correct offset
• For Killer Jigsaw we need 9 bits for the box numbers
• Finally, there is advantage to not storing the box pattern for Killer Sudoku. The 4 bits we save gets us over the 5 bytes per cell boundary to 4 bytes per cell.

for (y = 0; y < 9; y++)
	for (x = 0; x < 9; x++) {
		p = [cell box number];  //  0 if Killer Sudoku
		p = (p << 3) + [cage colour 0..4];  //  shift by 3 and add next value
		p = (p << 6) + [cage clue];  //  shift by 6 and add next value
		n = get the cell value or set of candidates as bits
		if( candidates )
		      n += 18; //  offset by 18
		else n += 9; //  offset by 9
		p = (p << 10) + n; //  shift by 10 and add next value

		h = p.toString(36); // convert to base 36
		//  pad the number if not 4 or 5 digits
		h = h.padStart((jigsaw killer)? 5 : 4, '0'); 
		s += h; // append to string being made
	}

// This splits a string into an array of elements each 4 or 5 characters long 
let cArr = astr.substring(3).match((jigsaw) ? /.{1,5}/g  /.{1,4}/g );
for (y = 0; y < 9; y++)
	for (x = 0; x < 9; x++) {
		p = parseInt(cArr [y * 9 + x], 36); // convert base 36 to decimal
		n = p & 1023; // first 10 bits
		if (n <= 18) {
			n -= 9; { // removed 'solved cell' offset
			// save the number as a solution
		} else {
			// save the number as a set of candidates
			n -= 18;
		}
		p >>= 10; // remove first 10 bits
		[cage clue] = p & 63;  // next 6 bits
		p >>= 6; // remove next 6 bits
		[cage colour] = (p & 7) + 1;  // next 3 bits
		[box number] = (p >> 3); // last4 bits
		 // Will be 0 for vanilla Sudoku
	}

let store = 6x6 array of zeros
for (y = 0; y < 9; y++)
	for (x = 0; x < 9; x++) {
		p = [cage colour 0..4] ;  //  Start with the cage colour
		p <<= 10;  //  shift 10 bits
		if( clue ) {
			p += [cage clue];  //  add clue
			if( cell_to_right_same_colour )
				store[y][x+1] = [operator_number];
			else if( cell_below_same_colour )
				store[y+1][x] = [operator_number];
			 //  else - 1-cell cage, ignore
		}  else if( store[y][x] != 0 ) {
			p += store[y][x]; // operator 1 to 4
		}
		n = get the cell value or set of candidates as bits
		if( candidates )
		      n += 12; //  offset by 12
		else n += 6; //  offset by 6
		p = (p << 8) + n; //  shift by 8 and add next value

		h = p.toString(36); // convert to base 36
		h = h.padStart(4, '0'); //  pad the number if not five digits
		s += h; // append to string being made
	}

// This splits a string into an array of elements each 4 characters long 
let cArr = astr.substring(3).match(/.{1,4}/g);
for (y = 0; y < 9; y++)
	for (x = 0; x < 9; x++) {
		p = parseInt(cArr [y * 9 + x], 36); // convert base 36 to decimal
		n = p & 255; // first 8 bits
		if (n <= 12) {
			n -= 6; { // removed 'solved cell' offset
			// save the number as a solution
		} else {
			// save the number as a set of candidates
			n -= 12;
		}
		p >>= 8; // remove first 8 bits
		op = p & 1023;  // could be clue or operand
		p >>= 10; // remove next 10 bits
		[cage colour] = p + 1;  // last 3 bits
		if( op ) {
			if( cell_above_same_colour or cell_left_same_colour ) {
				// puts the operand with the clue in the same cell:
				if( cell_above_same_colour ) opp[y-1][x] = op;
				if( cell_left_same_colour ) opp[y][x-1] = op;
			}
			else [cage clue] = op;  // must be a clue
		}
	}