AES-256 Decrypt

gaes.js

function addRoundKey(block, words, round) {
	const result = []
	for (let i = 0; i < 16; i++)
		result[i] = block[i] ^ words[round][i]
	return result
}

const shift = [0, 13, 10, 7, 4, 1, 14, 11, 8, 5, 2, 15, 12, 9, 6, 3]

function shiftRows(block) {
	const result = []
	for (let i = 0; i < 16; i++)
		result[i] = block[shift[i]]
	return result
}

function mixColumns(state) {
	const result = []
	for (let i = 0; i < 4; i++)
	for (let ii = 0, iii = i * 4; ii < 4; ii++)
	for (let iiii = 0, iiiii = iii + ii, iiiiii = ii - 4; iiii < 4; iiii++)
	result[iiiii] ^= GX[(iiii - iiiiii) % 4][state[iiii + iii]]
	return result
}

function decryptBlock(block, words) {
	block = addRoundKey(block, words, 14)
	for (let round = 13; round > -1; round--) {
		block = shiftRows(block)
		for (let i = 0; i < 16; i++) block[i] = SBoxInv[block[i]]
		block = addRoundKey(block, words, round)
		if (round > 0) block = mixColumns(block)
	}
	return block
}

function rawDecrypt(cryptArr, key, iv) {
	const numBlocks = cryptArr.length / 16,	
	cipherBlocks = []
	for (let i = 0; i < numBlocks; i++) cipherBlocks.push(cryptArr.slice(i * 16, (i + 1) * 16))
	const plainBlocks = []
	for (let i = cipherBlocks.length - 1; i >= 0; i--) {
		const block = plainBlocks[i] = [],
		block1 = decryptBlock(cipherBlocks[i], key),
		block2 = (i === 0) ? iv : cipherBlocks[i - 1]
        for (let ii = 0; ii < 16; ii++) block[ii] = block1[ii] ^ block2[ii]
	}
	let string = ''
	for (let i = 0; i < numBlocks - 1; i++) for (let ii = 0; ii < 16; ii++) string += String.fromCharCode(plainBlocks[i][ii])
	const block = plainBlocks[numBlocks - 1]
	for (let i = 0; i < 16 - block[15]; i++) string += String.fromCharCode(block[i])
	return decodeURIComponent(escape(string))
}

function s2a(string) {
	const result = []
	for (let i = 0; i < string.length; i++) result[i] = string.charCodeAt(i)
	return result
}

export function dec(string, pass) {
	string = s2a(atob(string)), pass = s2a(unescape(encodeURIComponent(pass)))
	let result = MD5(pass = pass.concat([...string.slice(8, 16)])), last = result
	for (let i = 1; i < 3; i++) result = result.concat(last = MD5(last.concat(pass)))
	return rawDecrypt(string.slice(16), expandKey(result.slice(0, 32)), result.slice(32, 48))
}

function subWord(w) {
	for (let i = 0; i < 4; i++) w[i] = SBox[w[i]]
	return w
}

function expandKey(key) {
	const w = []
	for (let i = 0; i < 8; i++) w[i] = key.slice(i * 4)
	for (let i = 8; i < 60; i++) {
		let j = [...w[i - 1]]
		if (i % 8 === 0) {
			j.push(j.shift())
			j = subWord(j)
			j[0] ^= Rcon[i / 8 - 1]
		} else if (8 > 6 && i % 8 === 4) j = subWord(j)
		w[i] = []
        for (let ii = 0; ii < 4; ii++) w[i][ii] = w[i - 8][ii] ^ j[ii]
	}
	const result = []
	for (let i = 0; i < 15; i++) {
		result[i] = []
		for (let ii = 0; ii < 4; ii++) result[i].push(...w[i * 4 + ii])
	}
	return result
}

//

const Rcon = [
	1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154, 47, 94,
	188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145
]

const SBoxInv = [
	82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215,
	251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222,
	233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66,
	250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109,
	139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204,
	93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70,
	87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 228,
	88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, 193, 175,
	189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 234, 151, 242,
	207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, 53, 133,
	226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197,
	137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210,
	121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, 51, 136,
	7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 127, 169, 25,
	181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 224, 59, 77,
	174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, 23, 43, 4, 126,
	186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125
]

const SBox = [
	99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171,
	118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156,
	164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241,
	113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226,
	235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179,
	41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57,
	74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127,
	80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218,
	33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68,23, 196, 167, 126,
	61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184,
	20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172,
	98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86,
	244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232,
	221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97,
	53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148,
	155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66,
	104, 65, 153, 45, 15, 176, 84, 187, 22
]

const GX = [[ // ['GEX', 'GBX', 'GDX', 'G9X']
    0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62,
    0x48, 0x46, 0x54, 0x5a, 0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca,
    0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba, 0xdb, 0xd5, 0xc7, 0xc9,
    0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
    0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59,
    0x73, 0x7d, 0x6f, 0x61, 0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87,
    0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7, 0x4d, 0x43, 0x51, 0x5f,
    0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17,
    0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14,
    0x3e, 0x30, 0x22, 0x2c, 0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc,
    0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc, 0x41, 0x4f, 0x5d, 0x53,
    0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b,
    0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3,
    0xe9, 0xe7, 0xf5, 0xfb, 0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0,
    0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0, 0x7a, 0x74, 0x66, 0x68,
    0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20,
    0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e,
    0xa4, 0xaa, 0xb8, 0xb6, 0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26,
    0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56, 0x37, 0x39, 0x2b, 0x25,
    0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
    0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5,
    0x9f, 0x91, 0x83, 0x8d
], [
    0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45,
    0x74, 0x7f, 0x62, 0x69, 0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81,
    0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9, 0x7b, 0x70, 0x6d, 0x66,
    0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
    0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e,
    0xbf, 0xb4, 0xa9, 0xa2, 0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7,
    0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f, 0x46, 0x4d, 0x50, 0x5b,
    0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f,
    0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8,
    0xf9, 0xf2, 0xef, 0xe4, 0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c,
    0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54, 0xf7, 0xfc, 0xe1, 0xea,
    0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e,
    0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02,
    0x33, 0x38, 0x25, 0x2e, 0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd,
    0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5, 0x3c, 0x37, 0x2a, 0x21,
    0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55,
    0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44,
    0x75, 0x7e, 0x63, 0x68, 0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80,
    0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8, 0x7a, 0x71, 0x6c, 0x67,
    0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
    0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f,
    0xbe, 0xb5, 0xa8, 0xa3
], [
    0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f,
    0x5c, 0x51, 0x46, 0x4b, 0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3,
    0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b, 0xbb, 0xb6, 0xa1, 0xac,
    0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
    0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14,
    0x37, 0x3a, 0x2d, 0x20, 0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e,
    0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26, 0xbd, 0xb0, 0xa7, 0xaa,
    0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6,
    0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9,
    0x8a, 0x87, 0x90, 0x9d, 0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25,
    0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d, 0xda, 0xd7, 0xc0, 0xcd,
    0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91,
    0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75,
    0x56, 0x5b, 0x4c, 0x41, 0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42,
    0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a, 0xb1, 0xbc, 0xab, 0xa6,
    0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa,
    0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8,
    0xeb, 0xe6, 0xf1, 0xfc, 0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44,
    0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c, 0x0c, 0x01, 0x16, 0x1b,
    0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
    0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3,
    0x80, 0x8d, 0x9a, 0x97
], [
    0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53,
    0x6c, 0x65, 0x7e, 0x77, 0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf,
    0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7, 0x3b, 0x32, 0x29, 0x20,
    0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
    0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8,
    0xc7, 0xce, 0xd5, 0xdc, 0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49,
    0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01, 0xe6, 0xef, 0xf4, 0xfd,
    0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91,
    0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e,
    0x21, 0x28, 0x33, 0x3a, 0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2,
    0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa, 0xec, 0xe5, 0xfe, 0xf7,
    0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b,
    0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f,
    0x10, 0x19, 0x02, 0x0b, 0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8,
    0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0, 0x47, 0x4e, 0x55, 0x5c,
    0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30,
    0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9,
    0xf6, 0xff, 0xe4, 0xed, 0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35,
    0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d, 0xa1, 0xa8, 0xb3, 0xba,
    0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
    0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62,
    0x5d, 0x54, 0x4f, 0x46
]]

function strhex(str, size) {
	const ret = []
	for (let i = 0; i < str.length; i++)
		ret[i] = parseInt(str.substr(i * size, size), 16)
	return ret
}

function addUnsigned(lX, lY) {
	const lX4 = lX & 0x40000000
	const lY4 = lY & 0x40000000
	const lX8 = lX & 0x80000000
	const lY8 = lY & 0x80000000
	const lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF)
	if (lX4 & lY4)
		return lResult ^ 0x80000000 ^ lX8 ^ lY8
	else if (lX4 | lY4) 
		return lResult ^ (lResult & 0x40000000 ? 0xC0000000 : 0x40000000) ^ lX8 ^ lY8
	else
		return lResult ^ lX8 ^ lY8
}

function rotateLeft(lValue, iShiftBits) {
	return lValue << iShiftBits | lValue >>> 32 - iShiftBits
}

function wordToHex(lValue) {
	const wordToHexArr = []
	for (let lCount = 0; lCount <= 3; lCount++)
		wordToHexArr.push(lValue >>> lCount * 8 & 255)
	return wordToHexArr
}

function convertToWordArray(numArr) {
	const words = numArr.length + 8
	const lNumberOfWords = ((words - words % 64) / 64 + 1) * 16
	let lByteCount, lWordCount, lBytePosition = 0
	const lWordArray = []
	for (lByteCount = 0; lByteCount < numArr.length; lByteCount++)
		lWordArray[lWordCount = (lByteCount - lByteCount % 4) / 4] = lWordArray[lWordCount] | numArr[lByteCount] << (lBytePosition = lByteCount % 4 * 8)
	lWordCount = (lByteCount - lByteCount % 4) / 4
	lBytePosition = lByteCount % 4 * 8
	lWordArray[lWordCount] = lWordArray[lWordCount] | 0x80 << lBytePosition
	lWordArray[lNumberOfWords - 2] = numArr.length << 3
	lWordArray[lNumberOfWords - 1] = numArr.length >>> 29
	return lWordArray
}

const rnd = strhex('67452301efcdab8998badcfe10325476d76aa478e8c7b756242070dbc1bdceeef57c0faf4787c62aa8304613fd469501698098d88b44f7afffff5bb1895cd7be6b901122fd987193a679438e49b40821f61e2562c040b340265e5a51e9b6c7aad62f105d02441453d8a1e681e7d3fbc821e1cde6c33707d6f4d50d87455a14eda9e3e905fcefa3f8676f02d98d2a4c8afffa39428771f6816d9d6122fde5380ca4beea444bdecfa9f6bb4b60bebfbc70289b7ec6eaa127fad4ef308504881d05d9d4d039e6db99e51fa27cf8c4ac5665f4292244432aff97ab9423a7fc93a039655b59c38f0ccc92ffeff47d85845dd16fa87e4ffe2ce6e0a30143144e0811a1f7537e82bd3af2352ad7d2bbeb86d391', 8)

function f(x, y, z) {
	return x & y | ~x & z
}

function g(x, y, z) {
	return x & z | y & ~z
}

function h(x, y, z) {
	return x ^ y ^ z
}

function i(x, y, z) {
	return y ^ (x | ~z)
}

function _f(a, b, c, d, x, s, ac, f) {
	return addUnsigned(rotateLeft(addUnsigned(a, addUnsigned(addUnsigned(f(b, c, d), x), ac)), s), b)
}

function MD5(numArr) {
	const x = convertToWordArray(numArr)
	let a = rnd[0], b = rnd[1], c = rnd[2], d = rnd[3]
	for (let k = 0; k < x.length; k += 16) {
		const AA = a, BB = b, CC = c, DD = d
		a = _f(a, b, c, d, x[k + 0], 7, rnd[4], f)
		d = _f(d, a, b, c, x[k + 1], 12, rnd[5], f)
		c = _f(c, d, a, b, x[k + 2], 17, rnd[6], f)
		b = _f(b, c, d, a, x[k + 3], 22, rnd[7], f)
		a = _f(a, b, c, d, x[k + 4], 7, rnd[8], f)
		d = _f(d, a, b, c, x[k + 5], 12, rnd[9], f)
		c = _f(c, d, a, b, x[k + 6], 17, rnd[10], f)
		b = _f(b, c, d, a, x[k + 7], 22, rnd[11], f)
		a = _f(a, b, c, d, x[k + 8], 7, rnd[12], f)
		d = _f(d, a, b, c, x[k + 9], 12, rnd[13], f)
		c = _f(c, d, a, b, x[k + 10], 17, rnd[14], f)
		b = _f(b, c, d, a, x[k + 11], 22, rnd[15], f)
		a = _f(a, b, c, d, x[k + 12], 7, rnd[16], f)
		d = _f(d, a, b, c, x[k + 13], 12, rnd[17], f)
		c = _f(c, d, a, b, x[k + 14], 17, rnd[18], f)
		b = _f(b, c, d, a, x[k + 15], 22, rnd[19], f)
		a = _f(a, b, c, d, x[k + 1], 5, rnd[20], g)
		d = _f(d, a, b, c, x[k + 6], 9, rnd[21], g)
		c = _f(c, d, a, b, x[k + 11], 14, rnd[22], g)
		b = _f(b, c, d, a, x[k + 0], 20, rnd[23], g)
		a = _f(a, b, c, d, x[k + 5], 5, rnd[24], g)
		d = _f(d, a, b, c, x[k + 10], 9, rnd[25], g)
		c = _f(c, d, a, b, x[k + 15], 14, rnd[26], g)
		b = _f(b, c, d, a, x[k + 4], 20, rnd[27], g)
		a = _f(a, b, c, d, x[k + 9], 5, rnd[28], g)
		d = _f(d, a, b, c, x[k + 14], 9, rnd[29], g)
		c = _f(c, d, a, b, x[k + 3], 14, rnd[30], g)
		b = _f(b, c, d, a, x[k + 8], 20, rnd[31], g)
		a = _f(a, b, c, d, x[k + 13], 5, rnd[32], g)
		d = _f(d, a, b, c, x[k + 2], 9, rnd[33], g)
		c = _f(c, d, a, b, x[k + 7], 14, rnd[34], g)
		b = _f(b, c, d, a, x[k + 12], 20, rnd[35], g)
		a = _f(a, b, c, d, x[k + 5], 4, rnd[36], h)
		d = _f(d, a, b, c, x[k + 8], 11, rnd[37], h)
		c = _f(c, d, a, b, x[k + 11], 16, rnd[38], h)
		b = _f(b, c, d, a, x[k + 14], 23, rnd[39], h)
		a = _f(a, b, c, d, x[k + 1], 4, rnd[40], h)
		d = _f(d, a, b, c, x[k + 4], 11, rnd[41], h)
		c = _f(c, d, a, b, x[k + 7], 16, rnd[42], h)
		b = _f(b, c, d, a, x[k + 10], 23, rnd[43], h)
		a = _f(a, b, c, d, x[k + 13], 4, rnd[44], h)
		d = _f(d, a, b, c, x[k + 0], 11, rnd[45], h)
		c = _f(c, d, a, b, x[k + 3], 16, rnd[46], h)
		b = _f(b, c, d, a, x[k + 6], 23, rnd[47], h)
		a = _f(a, b, c, d, x[k + 9], 4, rnd[48], h)
		d = _f(d, a, b, c, x[k + 12], 11, rnd[49], h)
		c = _f(c, d, a, b, x[k + 15], 16, rnd[50], h)
		b = _f(b, c, d, a, x[k + 2], 23, rnd[51], h)
		a = _f(a, b, c, d, x[k + 0], 6, rnd[52], i)
		d = _f(d, a, b, c, x[k + 7], 10, rnd[53], i)
		c = _f(c, d, a, b, x[k + 14], 15, rnd[54], i)
		b = _f(b, c, d, a, x[k + 5], 21, rnd[55], i)
		a = _f(a, b, c, d, x[k + 12], 6, rnd[56], i)
		d = _f(d, a, b, c, x[k + 3], 10, rnd[57], i)
		c = _f(c, d, a, b, x[k + 10], 15, rnd[58], i)
		b = _f(b, c, d, a, x[k + 1], 21, rnd[59], i)
		a = _f(a, b, c, d, x[k + 8], 6, rnd[60], i)
		d = _f(d, a, b, c, x[k + 15], 10, rnd[61], i)
		c = _f(c, d, a, b, x[k + 6], 15, rnd[62], i)
		b = _f(b, c, d, a, x[k + 13], 21, rnd[63], i)
		a = _f(a, b, c, d, x[k + 4], 6, rnd[64], i)
		d = _f(d, a, b, c, x[k + 11], 10, rnd[65], i)
		c = _f(c, d, a, b, x[k + 2], 15, rnd[66], i)
		b = _f(b, c, d, a, x[k + 9], 21, rnd[67], i)
		a = addUnsigned(a, AA)
		b = addUnsigned(b, BB)
		c = addUnsigned(c, CC)
		d = addUnsigned(d, DD)
	}

	return wordToHex(a).concat(wordToHex(b), wordToHex(c), wordToHex(d))
}