/* * Aug 8, 2011 Bob Pearson with help from Joakim Tjernlund and George Spelvin * cleaned up code to current version of sparse and added the slicing-by-8 * algorithm to the closely similar existing slicing-by-4 algorithm. * * Oct 15, 2000 Matt Domsch <Matt_Domsch@dell.com> * Nicer crc32 functions/docs submitted by linux@horizon.com.  Thanks! * Code was from the public domain, copyright abandoned.  Code was * subsequently included in the kernel, thus was re-licensed under the * GNU GPL v2. * * Oct 12, 2000 Matt Domsch <Matt_Domsch@dell.com> * Same crc32 function was used in 5 other places in the kernel. * I made one version, and deleted the others. * There are various incantations of crc32().  Some use a seed of 0 or ~0. * Some xor at the end with ~0.  The generic crc32() function takes * seed as an argument, and doesn't xor at the end.  Then individual * users can do whatever they need. *   drivers/net/smc9194.c uses seed ~0, doesn't xor with ~0. *   fs/jffs2 uses seed 0, doesn't xor with ~0. *   fs/partitions/efi.c uses seed ~0, xor's with ~0. * * This source code is licensed under the GNU General Public License, * Version 2.  See the file COPYING for more details. */ /* see: Documentation/crc32.txt for a description of algorithms */ #include <linux/crc32.h>#include <linux/module.h>#include <linux/types.h>#include <linux/sched.h>#include "crc32defs.h" #if CRC_LE_BITS > 8# define tole(x) ((__force u32) __constant_cpu_to_le32(x))#else# define tole(x) (x)#endif #if CRC_BE_BITS > 8# define tobe(x) ((__force u32) __constant_cpu_to_be32(x))#else# define tobe(x) (x)#endif #include "crc32table.h" MODULE_AUTHOR("Matt Domsch <Matt_Domsch@dell.com>");MODULE_DESCRIPTION("Various CRC32 calculations");MODULE_LICENSE("GPL"); #define GF2_DIM		32 static u32 gf2_matrix_times(u32 *mat, u32 vec){	u32 sum = 0; 	while (vec) {		if (vec & 1)			sum ^= *mat;		vec >>= 1;		mat++;	} 	return sum;} static void gf2_matrix_square(u32 *square, u32 *mat){	int i; 	for (i = 0; i < GF2_DIM; i++)		square[i] = gf2_matrix_times(mat, mat[i]);} #if CRC_LE_BITS > 8 || CRC_BE_BITS > 8 /* implements slicing-by-4 or slicing-by-8 algorithm */static inline u32crc32_body(u32 crc, unsigned char const *buf, size_t len, const u32 (*tab)[256]){# ifdef __LITTLE_ENDIAN#  define DO_CRC(x) crc = t0[(crc ^ (x)) & 255] ^ (crc >> 8)#  define DO_CRC4 (t3[(q) & 255] ^ t2[(q >> 8) & 255] ^ \		   t1[(q >> 16) & 255] ^ t0[(q >> 24) & 255])#  define DO_CRC8 (t7[(q) & 255] ^ t6[(q >> 8) & 255] ^ \		   t5[(q >> 16) & 255] ^ t4[(q >> 24) & 255])# else#  define DO_CRC(x) crc = t0[((crc >> 24) ^ (x)) & 255] ^ (crc << 8)#  define DO_CRC4 (t0[(q) & 255] ^ t1[(q >> 8) & 255] ^ \		   t2[(q >> 16) & 255] ^ t3[(q >> 24) & 255])#  define DO_CRC8 (t4[(q) & 255] ^ t5[(q >> 8) & 255] ^ \		   t6[(q >> 16) & 255] ^ t7[(q >> 24) & 255])# endif	const u32 *b;	size_t    rem_len;# ifdef CONFIG_X86	size_t i;# endif	const u32 *t0=tab[0], *t1=tab[1], *t2=tab[2], *t3=tab[3];# if CRC_LE_BITS != 32	const u32 *t4 = tab[4], *t5 = tab[5], *t6 = tab[6], *t7 = tab[7];# endif	u32 q; 	/* Align it */	if (unlikely((long)buf & 3 && len)) {		do {			DO_CRC(*buf++);		} while ((--len) && ((long)buf)&3);	} # if CRC_LE_BITS == 32	rem_len = len & 3;	len = len >> 2;# else	rem_len = len & 7;	len = len >> 3;# endif 	b = (const u32 *)buf;# ifdef CONFIG_X86	--b;	for (i = 0; i < len; i++) {# else	for (--b; len; --len) {# endif		q = crc ^ *++b; /* use pre increment for speed */# if CRC_LE_BITS == 32		crc = DO_CRC4;# else		crc = DO_CRC8;		q = *++b;		crc ^= DO_CRC4;# endif	}	len = rem_len;	/* And the last few bytes */	if (len) {		u8 *p = (u8 *)(b + 1) - 1;# ifdef CONFIG_X86		for (i = 0; i < len; i++)			DO_CRC(*++p); /* use pre increment for speed */# else		do {			DO_CRC(*++p); /* use pre increment for speed */		} while (--len);# endif	}	return crc;#undef DO_CRC#undef DO_CRC4#undef DO_CRC8}#endif /* For conditions of distribution and use, see copyright notice in zlib.h */static u32 crc32_generic_combine(u32 crc1, u32 crc2, size_t len2,				 u32 polynomial){	u32 even[GF2_DIM]; /* Even-power-of-two zeros operator */	u32 odd[GF2_DIM];  /* Odd-power-of-two zeros operator  */	u32 row;	int i; 	if (len2 <= 0)		return crc1; 	/* Put operator for one zero bit in odd */	odd[0] = polynomial;	row = 1;	for (i = 1; i < GF2_DIM; i++) {		odd[i] = row;		row <<= 1;	} 	gf2_matrix_square(even, odd); /* Put operator for two zero bits in even */	gf2_matrix_square(odd, even); /* Put operator for four zero bits in odd */ 	/* Apply len2 zeros to crc1 (first square will put the operator for one	 * zero byte, eight zero bits, in even).	 */	do {		/* Apply zeros operator for this bit of len2 */		gf2_matrix_square(even, odd);		if (len2 & 1)			crc1 = gf2_matrix_times(even, crc1);		len2 >>= 1;		/* If no more bits set, then done */		if (len2 == 0)			break;		/* Another iteration of the loop with odd and even swapped */		gf2_matrix_square(odd, even);		if (len2 & 1)			crc1 = gf2_matrix_times(odd, crc1);		len2 >>= 1;	} while (len2 != 0); 	crc1 ^= crc2;	return crc1;} /** * crc32_le_generic() - Calculate bitwise little-endian Ethernet AUTODIN II *			CRC32/CRC32C * @crc: seed value for computation.  ~0 for Ethernet, sometimes 0 for other *	 uses, or the previous crc32/crc32c value if computing incrementally. * @p: pointer to buffer over which CRC32/CRC32C is run * @len: length of buffer @p * @tab: little-endian Ethernet table * @polynomial: CRC32/CRC32c LE polynomial */static inline u32 __pure crc32_le_generic(u32 crc, unsigned char const *p,					  size_t len, const u32 (*tab)[256],					  u32 polynomial){#if CRC_LE_BITS == 1	int i;	while (len--) {		crc ^= *p++;		for (i = 0; i < 8; i++)			crc = (crc >> 1) ^ ((crc & 1) ? polynomial : 0);	}# elif CRC_LE_BITS == 2	while (len--) {		crc ^= *p++;		crc = (crc >> 2) ^ tab[0][crc & 3];		crc = (crc >> 2) ^ tab[0][crc & 3];		crc = (crc >> 2) ^ tab[0][crc & 3];		crc = (crc >> 2) ^ tab[0][crc & 3];	}# elif CRC_LE_BITS == 4	while (len--) {		crc ^= *p++;		crc = (crc >> 4) ^ tab[0][crc & 15];		crc = (crc >> 4) ^ tab[0][crc & 15];	}# elif CRC_LE_BITS == 8	/* aka Sarwate algorithm */	while (len--) {		crc ^= *p++;		crc = (crc >> 8) ^ tab[0][crc & 255];	}# else	crc = (__force u32) __cpu_to_le32(crc);	crc = crc32_body(crc, p, len, tab);	crc = __le32_to_cpu((__force __le32)crc);#endif	return crc;} #if CRC_LE_BITS == 1u32 __pure crc32_le(u32 crc, unsigned char const *p, size_t len){	return crc32_le_generic(crc, p, len, NULL, CRCPOLY_LE);}u32 __pure __crc32c_le(u32 crc, unsigned char const *p, size_t len){	return crc32_le_generic(crc, p, len, NULL, CRC32C_POLY_LE);}#elseu32 __pure crc32_le(u32 crc, unsigned char const *p, size_t len){	return crc32_le_generic(crc, p, len,			(const u32 (*)[256])crc32table_le, CRCPOLY_LE);}u32 __pure __crc32c_le(u32 crc, unsigned char const *p, size_t len){	return crc32_le_generic(crc, p, len,			(const u32 (*)[256])crc32ctable_le, CRC32C_POLY_LE);}#endifu32 __pure crc32_le_combine(u32 crc1, u32 crc2, size_t len2){	return crc32_generic_combine(crc1, crc2, len2, CRCPOLY_LE);} u32 __pure __crc32c_le_combine(u32 crc1, u32 crc2, size_t len2){	return crc32_generic_combine(crc1, crc2, len2, CRC32C_POLY_LE);}EXPORT_SYMBOL(crc32_le);EXPORT_SYMBOL(crc32_le_combine);EXPORT_SYMBOL(__crc32c_le);EXPORT_SYMBOL(__crc32c_le_combine); /** * crc32_be_generic() - Calculate bitwise big-endian Ethernet AUTODIN II CRC32 * @crc: seed value for computation.  ~0 for Ethernet, sometimes 0 for *	other uses, or the previous crc32 value if computing incrementally. * @p: pointer to buffer over which CRC32 is run * @len: length of buffer @p * @tab: big-endian Ethernet table * @polynomial: CRC32 BE polynomial */static inline u32 __pure crc32_be_generic(u32 crc, unsigned char const *p,					  size_t len, const u32 (*tab)[256],					  u32 polynomial){#if CRC_BE_BITS == 1	int i;	while (len--) {		crc ^= *p++ << 24;		for (i = 0; i < 8; i++)			crc =			    (crc << 1) ^ ((crc & 0x80000000) ? polynomial :					  0);	}# elif CRC_BE_BITS == 2	while (len--) {		crc ^= *p++ << 24;		crc = (crc << 2) ^ tab[0][crc >> 30];		crc = (crc << 2) ^ tab[0][crc >> 30];		crc = (crc << 2) ^ tab[0][crc >> 30];		crc = (crc << 2) ^ tab[0][crc >> 30];	}# elif CRC_BE_BITS == 4	while (len--) {		crc ^= *p++ << 24;		crc = (crc << 4) ^ tab[0][crc >> 28];		crc = (crc << 4) ^ tab[0][crc >> 28];	}# elif CRC_BE_BITS == 8	while (len--) {		crc ^= *p++ << 24;		crc = (crc << 8) ^ tab[0][crc >> 24];	}# else	crc = (__force u32) __cpu_to_be32(crc);	crc = crc32_body(crc, p, len, tab);	crc = __be32_to_cpu((__force __be32)crc);# endif	return crc;} #if CRC_LE_BITS == 1u32 __pure crc32_be(u32 crc, unsigned char const *p, size_t len){	return crc32_be_generic(crc, p, len, NULL, CRCPOLY_BE);}#elseu32 __pure crc32_be(u32 crc, unsigned char const *p, size_t len){	return crc32_be_generic(crc, p, len,			(const u32 (*)[256])crc32table_be, CRCPOLY_BE);}#endifEXPORT_SYMBOL(crc32_be); #ifdef CONFIG_CRC32_SELFTEST /* 4096 random bytes */static u8 __attribute__((__aligned__(8))) test_buf[] ={	0x5b, 0x85, 0x21, 0xcb, 0x09, 0x68, 0x7d, 0x30,	0xc7, 0x69, 0xd7, 0x30, 0x92, 0xde, 0x59, 0xe4,	0xc9, 0x6e, 0x8b, 0xdb, 0x98, 0x6b, 0xaa, 0x60,	0xa8, 0xb5, 0xbc, 0x6c, 0xa9, 0xb1, 0x5b, 0x2c,	0xea, 0xb4, 0x92, 0x6a, 0x3f, 0x79, 0x91, 0xe4,	0xe9, 0x70, 0x51, 0x8c, 0x7f, 0x95, 0x6f, 0x1a,	0x56, 0xa1, 0x5c, 0x27, 0x03, 0x67, 0x9f, 0x3a,	0xe2, 0x31, 0x11, 0x29, 0x6b, 0x98, 0xfc, 0xc4,	0x53, 0x24, 0xc5, 0x8b, 0xce, 0x47, 0xb2, 0xb9,	0x32, 0xcb, 0xc1, 0xd0, 0x03, 0x57, 0x4e, 0xd4,	0xe9, 0x3c, 0xa1, 0x63, 0xcf, 0x12, 0x0e, 0xca,	0xe1, 0x13, 0xd1, 0x93, 0xa6, 0x88, 0x5c, 0x61,	0x5b, 0xbb, 0xf0, 0x19, 0x46, 0xb4, 0xcf, 0x9e,	0xb6, 0x6b, 0x4c, 0x3a, 0xcf, 0x60, 0xf9, 0x7a,	0x8d, 0x07, 0x63, 0xdb, 0x40, 0xe9, 0x0b, 0x6f,	0xad, 0x97, 0xf1, 0xed, 0xd0, 0x1e, 0x26, 0xfd,	0xbf, 0xb7, 0xc8, 0x04, 0x94, 0xf8, 0x8b, 0x8c,	0xf1, 0xab, 0x7a, 0xd4, 0xdd, 0xf3, 0xe8, 0x88,	0xc3, 0xed, 0x17, 0x8a, 0x9b, 0x40, 0x0d, 0x53,	0x62, 0x12, 0x03, 0x5f, 0x1b, 0x35, 0x32, 0x1f,	0xb4, 0x7b, 0x93, 0x78, 0x0d, 0xdb, 0xce, 0xa4,	0xc0, 0x47, 0xd5, 0xbf, 0x68, 0xe8, 0x5d, 0x74,	0x8f, 0x8e, 0x75, 0x1c, 0xb2, 0x4f, 0x9a, 0x60,	0xd1, 0xbe, 0x10, 0xf4, 0x5c, 0xa1, 0x53, 0x09,	0xa5, 0xe0, 0x09, 0x54, 0x85, 0x5c, 0xdc, 0x07,	0xe7, 0x21, 0x69, 0x7b, 0x8a, 0xfd, 0x90, 0xf1,	0x22, 0xd0, 0xb4, 0x36, 0x28, 0xe6, 0xb8, 0x0f,	0x39, 0xde, 0xc8, 0xf3, 0x86, 0x60, 0x34, 0xd2,	0x5e, 0xdf, 0xfd, 0xcf, 0x0f, 0xa9, 0x65, 0xf0,	0xd5, 0x4d, 0x96, 0x40, 0xe3, 0xdf, 0x3f, 0x95,	0x5a, 0x39, 0x19, 0x93, 0xf4, 0x75, 0xce, 0x22,	0x00, 0x1c, 0x93, 0xe2, 0x03, 0x66, 0xf4, 0x93,	0x73, 0x86, 0x81, 0x8e, 0x29, 0x44, 0x48, 0x86,	0x61, 0x7c, 0x48, 0xa3, 0x43, 0xd2, 0x9c, 0x8d,	0xd4, 0x95, 0xdd, 0xe1, 0x22, 0x89, 0x3a, 0x40,	0x4c, 0x1b, 0x8a, 0x04, 0xa8, 0x09, 0x69, 0x8b,	0xea, 0xc6, 0x55, 0x8e, 0x57, 0xe6, 0x64, 0x35,	0xf0, 0xc7, 0x16, 0x9f, 0x5d, 0x5e, 0x86, 0x40,	0x46, 0xbb, 0xe5, 0x45, 0x88, 0xfe, 0xc9, 0x63,	0x15, 0xfb, 0xf5, 0xbd, 0x71, 0x61, 0xeb, 0x7b,	0x78, 0x70, 0x07, 0x31, 0x03, 0x9f, 0xb2, 0xc8,	0xa7, 0xab, 0x47, 0xfd, 0xdf, 0xa0, 0x78, 0x72,	0xa4, 0x2a, 0xe4, 0xb6, 0xba, 0xc0, 0x1e, 0x86,	0x71, 0xe6, 0x3d, 0x18, 0x37, 0x70, 0xe6, 0xff,	0xe0, 0xbc, 0x0b, 0x22, 0xa0, 0x1f, 0xd3, 0xed,	0xa2, 0x55, 0x39, 0xab, 0xa8, 0x13, 0x73, 0x7c,	0x3f, 0xb2, 0xd6, 0x19, 0xac, 0xff, 0x99, 0xed,	0xe8, 0xe6, 0xa6, 0x22, 0xe3, 0x9c, 0xf1, 0x30,	0xdc, 0x01, 0x0a, 0x56, 0xfa, 0xe4, 0xc9, 0x99,	0xdd, 0xa8, 0xd8, 0xda, 0x35, 0x51, 0x73, 0xb4,	0x40, 0x86, 0x85, 0xdb, 0x5c, 0xd5, 0x85, 0x80,	0x14, 0x9c, 0xfd, 0x98, 0xa9, 0x82, 0xc5, 0x37,	0xff, 0x32, 0x5d, 0xd0, 0x0b, 0xfa, 0xdc, 0x04,	0x5e, 0x09, 0xd2, 0xca, 0x17, 0x4b, 0x1a, 0x8e,	0x15, 0xe1, 0xcc, 0x4e, 0x52, 0x88, 0x35, 0xbd,	0x48, 0xfe, 0x15, 0xa0, 0x91, 0xfd, 0x7e, 0x6c,	0x0e, 0x5d, 0x79, 0x1b, 0x81, 0x79, 0xd2, 0x09,	0x34, 0x70, 0x3d, 0x81, 0xec, 0xf6, 0x24, 0xbb,	0xfb, 0xf1, 0x7b, 0xdf, 0x54, 0xea, 0x80, 0x9b,	0xc7, 0x99, 0x9e, 0xbd, 0x16, 0x78, 0x12, 0x53,	0x5e, 0x01, 0xa7, 0x4e, 0xbd, 0x67, 0xe1, 0x9b,	0x4c, 0x0e, 0x61, 0x45, 0x97, 0xd2, 0xf0, 0x0f,	0xfe, 0x15, 0x08, 0xb7, 0x11, 0x4c, 0xe7, 0xff,	0x81, 0x53, 0xff, 0x91, 0x25, 0x38, 0x7e, 0x40,	0x94, 0xe5, 0xe0, 0xad, 0xe6, 0xd9, 0x79, 0xb6,	0x92, 0xc9, 0xfc, 0xde, 0xc3, 0x1a, 0x23, 0xbb,	0xdd, 0xc8, 0x51, 0x0c, 0x3a, 0x72, 0xfa, 0x73,	0x6f, 0xb7, 0xee, 0x61, 0x39, 0x03, 0x01, 0x3f,	0x7f, 0x94, 0x2e, 0x2e, 0xba, 0x3a, 0xbb, 0xb4,	0xfa, 0x6a, 0x17, 0xfe, 0xea, 0xef, 0x5e, 0x66,	0x97, 0x3f, 0x32, 0x3d, 0xd7, 0x3e, 0xb1, 0xf1,	0x6c, 0x14, 0x4c, 0xfd, 0x37, 0xd3, 0x38, 0x80,	0xfb, 0xde, 0xa6, 0x24, 0x1e, 0xc8, 0xca, 0x7f,	0x3a, 0x93, 0xd8, 0x8b, 0x18, 0x13, 0xb2, 0xe5,	0xe4, 0x93, 0x05, 0x53, 0x4f, 0x84, 0x66, 0xa7,	0x58, 0x5c, 0x7b, 0x86, 0x52, 0x6d, 0x0d, 0xce,	0xa4, 0x30, 0x7d, 0xb6, 0x18, 0x9f, 0xeb, 0xff,	0x22, 0xbb, 0x72, 0x29, 0xb9, 0x44, 0x0b, 0x48,	0x1e, 0x84, 0x71, 0x81, 0xe3, 0x6d, 0x73, 0x26,	0x92, 0xb4, 0x4d, 0x2a, 0x29, 0xb8, 0x1f, 0x72,	0xed, 0xd0, 0xe1, 0x64, 0x77, 0xea, 0x8e, 0x88,	0x0f, 0xef, 0x3f, 0xb1, 0x3b, 0xad, 0xf9, 0xc9,	0x8b, 0xd0, 0xac, 0xc6, 0xcc, 0xa9, 0x40, 0xcc,	0x76, 0xf6, 0x3b, 0x53, 0xb5, 0x88, 0xcb, 0xc8,	0x37, 0xf1, 0xa2, 0xba, 0x23, 0x15, 0x99, 0x09,	0xcc, 0xe7, 0x7a, 0x3b, 0x37, 0xf7, 0x58, 0xc8,	0x46, 0x8c, 0x2b, 0x2f, 0x4e, 0x0e, 0xa6, 0x5c,	0xea, 0x85, 0x55, 0xba, 0x02, 0x0e, 0x0e, 0x48,	0xbc, 0xe1, 0xb1, 0x01, 0x35, 0x79, 0x13, 0x3d,	0x1b, 0xc0, 0x53, 0x68, 0x11, 0xe7, 0x95, 0x0f,	0x9d, 0x3f, 0x4c, 0x47, 0x7b, 0x4d, 0x1c, 0xae,	0x50, 0x9b, 0xcb, 0xdd, 0x05, 0x8d, 0x9a, 0x97,	0xfd, 0x8c, 0xef, 0x0c, 0x1d, 0x67, 0x73, 0xa8,	0x28, 0x36, 0xd5, 0xb6, 0x92, 0x33, 0x40, 0x75,	0x0b, 0x51, 0xc3, 0x64, 0xba, 0x1d, 0xc2, 0xcc,	0xee, 0x7d, 0x54, 0x0f, 0x27, 0x69, 0xa7, 0x27,	0x63, 0x30, 0x29, 0xd9, 0xc8, 0x84, 0xd8, 0xdf,	0x9f, 0x68, 0x8d, 0x04, 0xca, 0xa6, 0xc5, 0xc7,	0x7a, 0x5c, 0xc8, 0xd1, 0xcb, 0x4a, 0xec, 0xd0,	0xd8, 0x20, 0x69, 0xc5, 0x17, 0xcd, 0x78, 0xc8,	0x75, 0x23, 0x30, 0x69, 0xc9, 0xd4, 0xea, 0x5c,	0x4f, 0x6b, 0x86, 0x3f, 0x8b, 0xfe, 0xee, 0x44,	0xc9, 0x7c, 0xb7, 0xdd, 0x3e, 0xe5, 0xec, 0x54,	0x03, 0x3e, 0xaa, 0x82, 0xc6, 0xdf, 0xb2, 0x38,	0x0e, 0x5d, 0xb3, 0x88, 0xd9, 0xd3, 0x69, 0x5f,	0x8f, 0x70, 0x8a, 0x7e, 0x11, 0xd9, 0x1e, 0x7b,	0x38, 0xf1, 0x42, 0x1a, 0xc0, 0x35, 0xf5, 0xc7,	0x36, 0x85, 0xf5, 0xf7, 0xb8, 0x7e, 0xc7, 0xef,	0x18, 0xf1, 0x63, 0xd6, 0x7a, 0xc6, 0xc9, 0x0e,	0x4d, 0x69, 0x4f, 0x84, 0xef, 0x26, 0x41, 0x0c,	0xec, 0xc7, 0xe0, 0x7e, 0x3c, 0x67, 0x01, 0x4c,	0x62, 0x1a, 0x20, 0x6f, 0xee, 0x47, 0x4d, 0xc0,	0x99, 0x13, 0x8d, 0x91, 0x4a, 0x26, 0xd4, 0x37,	0x28, 0x90, 0x58, 0x75, 0x66, 0x2b, 0x0a, 0xdf,	0xda, 0xee, 0x92, 0x25, 0x90, 0x62, 0x39, 0x9e,	0x44, 0x98, 0xad, 0xc1, 0x88, 0xed, 0xe4, 0xb4,	0xaf, 0xf5, 0x8c, 0x9b, 0x48, 0x4d, 0x56, 0x60,	0x97, 0x0f, 0x61, 0x59, 0x9e, 0xa6, 0x27, 0xfe,	0xc1, 0x91, 0x15, 0x38, 0xb8, 0x0f, 0xae, 0x61,	0x7d, 0x26, 0x13, 0x5a, 0x73, 0xff, 0x1c, 0xa3,	0x61, 0x04, 0x58, 0x48, 0x55, 0x44, 0x11, 0xfe,	0x15, 0xca, 0xc3, 0xbd, 0xca, 0xc5, 0xb4, 0x40,	0x5d, 0x1b, 0x7f, 0x39, 0xb5, 0x9c, 0x35, 0xec,	0x61, 0x15, 0x32, 0x32, 0xb8, 0x4e, 0x40, 0x9f,	0x17, 0x1f, 0x0a, 0x4d, 0xa9, 0x91, 0xef, 0xb7,	0xb0, 0xeb, 0xc2, 0x83, 0x9a, 0x6c, 0xd2, 0x79,	0x43, 0x78, 0x5e, 0x2f, 0xe5, 0xdd, 0x1a, 0x3c,	0x45, 0xab, 0x29, 0x40, 0x3a, 0x37, 0x5b, 0x6f,	0xd7, 0xfc, 0x48, 0x64, 0x3c, 0x49, 0xfb, 0x21,	0xbe, 0xc3, 0xff, 0x07, 0xfb, 0x17, 0xe9, 0xc9,	0x0c, 0x4c, 0x5c, 0x15, 0x9e, 0x8e, 0x22, 0x30,	0x0a, 0xde, 0x48, 0x7f, 0xdb, 0x0d, 0xd1, 0x2b,	0x87, 0x38, 0x9e, 0xcc, 0x5a, 0x01, 0x16, 0xee,	0x75, 0x49, 0x0d, 0x30, 0x01, 0x34, 0x6a, 0xb6,	0x9a, 0x5a, 0x2a, 0xec, 0xbb, 0x48, 0xac, 0xd3,	0x77, 0x83, 0xd8, 0x08, 0x86, 0x4f, 0x48, 0x09,	0x29, 0x41, 0x79, 0xa1, 0x03, 0x12, 0xc4, 0xcd,	0x90, 0x55, 0x47, 0x66, 0x74, 0x9a, 0xcc, 0x4f,	0x35, 0x8c, 0xd6, 0x98, 0xef, 0xeb, 0x45, 0xb9,	0x9a, 0x26, 0x2f, 0x39, 0xa5, 0x70, 0x6d, 0xfc,	0xb4, 0x51, 0xee, 0xf4, 0x9c, 0xe7, 0x38, 0x59,	0xad, 0xf4, 0xbc, 0x46, 0xff, 0x46, 0x8e, 0x60,	0x9c, 0xa3, 0x60, 0x1d, 0xf8, 0x26, 0x72, 0xf5,	0x72, 0x9d, 0x68, 0x80, 0x04, 0xf6, 0x0b, 0xa1,	0x0a, 0xd5, 0xa7, 0x82, 0x3a, 0x3e, 0x47, 0xa8,

Lines 1–500 of 1181. Load more