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
	MOVH	R4, R5			// 85c04000a5c04800

	// relocation instructions

	ROTRV	$63, R22	// 0036b7fe


//	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
//

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

        </module>
        <!--<module name="WhitespaceAround">-->
            <!-- everything except { and } -->

          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++
        }
      }

	AND	$1, X5					// 93f21200
	OR	X6, X5, X7				// b3e36200
	OR	X5, X6					// 33635300
	OR	$1, X5, X6				// 13e31200
	OR	$1, X5					// 93e21200
	XOR	X6, X5, X7				// b3c36200
	XOR	X5, X6					// 33435300
	XOR	$1, X5, X6				// 13c31200
	XOR	$1, X5					// 93c21200

	AUIPC	$0, X10					// 17050000
	AUIPC	$0, X11					// 97050000
	AUIPC	$1, X10					// 17150000
	AUIPC	$-524288, X15				// 97070080

	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

	if op == arm.AMRC {
		op1 = 1
	}
	bits, ok := ParseARMCondition(cond)
	if !ok {
		return
	}
	offset = (0xe << 24) | // opcode
		(op1 << 20) | // MCR/MRC
		((int64(bits) ^ arm.C_SCOND_XOR) << 28) | // scond
		((x0 & 15) << 8) | //coprocessor number
		((x1 & 7) << 21) | // coprocessor operation
		((x2 & 15) << 12) | // ARM register
		((x3 & 15) << 16) | // Crn
		((x4 & 15) << 0) | // Crm