keyIndex %= keyLength // Reassign to prevent overflow breaking counter.

          // Byte xor is experimental in Kotlin so we coerce bytes to int, xor them
          // and convert back to byte.
          val bufferInt: Int = buffer[i].toInt()
          val keyInt: Int = key[keyIndex].toInt()
          buffer[i] = (bufferInt xor keyInt).toByte()

          i++
          keyIndex++
        }
      }

	OR $16711680, R3, R4            // 646400ff

	XOR $1, R3                      // 68630001
	XOR $1, R3, R4                  // 68640001
	XOR $-1, R4                     // 3be0ffff7fe42278
	XOR $-1, R4, R5                 // 3be0ffff7fe52278
	XOR $65535, R5                  // 68a5ffff
	XOR $65535, R5, R6              // 68a6ffff
	XOR $65536, R6                  // 6cc60001
	XOR $65536, R6, R7              // 6cc70001

	OR	$4096, R4		// 3e00001484781500
	OR	$-1, R4, R5		// 1efcbf0285781500
	OR	$-1, R4			// 1efcbf0284781500
	XOR	$65536, R4, R5		// 1e02001485f81500
	XOR	$4096, R4, R5		// 3e00001485f81500
	XOR	$65536, R4		// 1e02001484f81500
	XOR	$4096, R4		// 3e00001484f81500
	XOR	$-1, R4, R5		// 1efcbf0285f81500
	XOR	$-1, R4			// 1efcbf0284f81500

	// relocation instructions
	MOVW	R4, name(SB)		// 1e00001ac4038029

func hashDeterministicString(m map[string]string) uint64 {
	// Seed (random)
	crc := uint64(0xc2b40bbac11a7295)
	// Xor each value to make order independent
	for k, v := range m {
		// Separate key and value with an individual xor with a random number.
		// Add values of each, so they cannot be trivially collided.

	OR	$74565, R4, R5			// 5e020014de178d0385781500
	OR	$4097, R4			// 3e000014de07800384781500
	OR	$4097, R4, R5			// 3e000014de07800385781500
	XOR	$74565, R4			// 5e020014de178d0384f81500
	XOR	$74565, R4, R5			// 5e020014de178d0385f81500
	XOR	$4097, R4			// 3e000014de07800384f81500
	XOR	$4097, R4, R5			// 3e000014de07800385f81500

	MOVWP	R5, -32768(R4)			// 1efcff13de931000c5038025
	MOVWP	R5, 32768(R4)			// 1e000010de931000c5038025

	ORW	$65536, R1            // a51a0001
	ORW	$-2, R1               // c01dfffffffe
	XOR	R1, R2                // b9820021
	XOR	R1, R2, R3            // b9e72031
	XOR	$1, R1                // c01700000001
	XOR	$131071, R1           // c0170001ffff
	XOR	$65536, R1            // c01700010000
	XOR	$-2, R1               // c0a1fffffffeb982001a
	XORW	R1, R2                // 1721
	XORW	R1, R2, R3            // b9f72031

//	LAND/LXOR/LNOR/LOR rreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	AND	R14, R8		// 010e4024
	XOR	R15, R9		// 012f4826
	NOR	R16, R10	// 01505027
	OR	R17, R11	// 01715825

//	LAND/LXOR/LOR imm ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	AND	$11, R17, R7	// 3227000b
	XOR	$341, R1, R23	// 38370155
	OR	$254, R25, R13	// 372d00fe
//

    sink().write(value.toByteArray())
  }

  fun writeLong(v: Long) {
    val sink = sink()

    val lengthBitCount: Int =
      if (v < 0L) {
        65 - java.lang.Long.numberOfLeadingZeros(v xor -1L)
      } else {
        65 - java.lang.Long.numberOfLeadingZeros(v)
      }

    val lengthByteCount = (lengthBitCount + 7) / 8
    for (shift in (lengthByteCount - 1) * 8 downTo 0 step 8) {

X6; \ XOR f, g, X5; \ XOR X8, X6; \ AND e, X5; \ ADD X6, h; \ XOR g, X5; \ ADD h, X5 // Calculate T2 in X6. // T2 = BIGSIGMA0(a) + Maj(a, b, c) // BIGSIGMA0(x) = ROTR(2,x) XOR ROTR(13,x) XOR ROTR(22,x) // Maj(x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z) // = ((y XOR z) AND x) XOR (y AND z) #define SHA256T2(a, b, c) \ RORW $2, a, X6; \ RORW $13, a, X7; \ RORW $22, a, X8; \ XOR X7, X6; \ XOR b, c, X9; \ AND b, c, X7; \ AND a, X9; \ XOR X8, X6; \ XOR X7, X9; \ ADD X9, X6 // Calculate T1 and T2, then...

f, g, X5; \ XOR X8, X6; \ AND e, X5; \ ADD X6, h; \ XOR g, X5; \ ADD h, X5 // Calculate T2 in X6. // T2 = BIGSIGMA0(a) + Maj(a, b, c) // BIGSIGMA0(x) = ROTR(28,x) XOR ROTR(34,x) XOR ROTR(39,x) // Maj(x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z) // = ((y XOR z) AND x) XOR (y AND z) #define SHA512T2(a, b, c) \ ROR $28, a, X6; \ ROR $34, a, X7; \ ROR $39, a, X8; \ XOR X7, X6; \ XOR b, c, X9; \ AND b, c, X7; \ AND a, X9; \ XOR X8, X6; \ XOR X7, X9; \ ADD X9, X6 // Calculate T1 and T2, then e = d +...