fork download
copy 
  1. importPackage(java.io);
  2. importPackage(java.lang);
  3.  
  4. // +----------------------------------------------------------------------+
  5. // | murmurHash3.js v2.1.2 (http://g...content-available-to-author-only...b.com/karanlyons/murmurHash.js)   |
  6. // | A javascript implementation of MurmurHash3's x86 hashing algorithms. |
  7. // |----------------------------------------------------------------------|
  8. // | Copyright (c) 2012 Karan Lyons                                       |
  9. // | Freely distributable under the MIT license.                          |
  10. // +----------------------------------------------------------------------+
  11.  
  12.  
  13. ;(function (root, undefined) {
  14. 	'use strict';
  15.  
  16. 	// Create a local object that'll be exported or referenced globally.
  17. 	var library = {
  18. 		'version': '2.1.2',
  19. 		'x86': {},
  20. 		'x64': {}
  21. 	};
  22.  
  23.  
  24.  
  25.  
  26. 	// PRIVATE FUNCTIONS
  27. 	// -----------------
  28.  
  29. 	function _x86Multiply(m, n) {
  30. 		//
  31. 		// Given two 32bit ints, returns the two multiplied together as a
  32. 		// 32bit int.
  33. 		//
  34.  
  35. 		return ((m & 0xffff) * n) + ((((m >>> 16) * n) & 0xffff) << 16);
  36. 	}
  37.  
  38.  
  39. 	function _x86Rotl(m, n) {
  40. 		//
  41. 		// Given a 32bit int and an int representing a number of bit positions,
  42. 		// returns the 32bit int rotated left by that number of positions.
  43. 		//
  44.  
  45. 		return (m << n) | (m >>> (32 - n));
  46. 	}
  47.  
  48.  
  49. 	function _x86Fmix(h) {
  50. 		//
  51. 		// Given a block, returns murmurHash3's final x86 mix of that block.
  52. 		//
  53.  
  54. 		h ^= h >>> 16;
  55. 		h  = _x86Multiply(h, 0x85ebca6b);
  56. 		h ^= h >>> 13;
  57. 		h  = _x86Multiply(h, 0xc2b2ae35);
  58. 		h ^= h >>> 16;
  59.  
  60. 		return h;
  61. 	}
  62.  
  63.  
  64. 	function _x64Add(m, n) {
  65. 		//
  66. 		// Given two 64bit ints (as an array of two 32bit ints) returns the two
  67. 		// added together as a 64bit int (as an array of two 32bit ints).
  68. 		//
  69.  
  70. 		m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];
  71. 		n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];
  72. 		var o = [0, 0, 0, 0];
  73.  
  74. 		o[3] += m[3] + n[3];
  75. 		o[2] += o[3] >>> 16;
  76. 		o[3] &= 0xffff;
  77.  
  78. 		o[2] += m[2] + n[2];
  79. 		o[1] += o[2] >>> 16;
  80. 		o[2] &= 0xffff;
  81.  
  82. 		o[1] += m[1] + n[1];
  83. 		o[0] += o[1] >>> 16;
  84. 		o[1] &= 0xffff;
  85.  
  86. 		o[0] += m[0] + n[0];
  87. 		o[0] &= 0xffff;
  88.  
  89. 		return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];
  90. 	}
  91.  
  92.  
  93. 	function _x64Multiply(m, n) {
  94. 		//
  95. 		// Given two 64bit ints (as an array of two 32bit ints) returns the two
  96. 		// multiplied together as a 64bit int (as an array of two 32bit ints).
  97. 		//
  98.  
  99. 		m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];
  100. 		n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];
  101. 		var o = [0, 0, 0, 0];
  102.  
  103. 		o[3] += m[3] * n[3];
  104. 		o[2] += o[3] >>> 16;
  105. 		o[3] &= 0xffff;
  106.  
  107. 		o[2] += m[2] * n[3];
  108. 		o[1] += o[2] >>> 16;
  109. 		o[2] &= 0xffff;
  110.  
  111. 		o[2] += m[3] * n[2];
  112. 		o[1] += o[2] >>> 16;
  113. 		o[2] &= 0xffff;
  114.  
  115. 		o[1] += m[1] * n[3];
  116. 		o[0] += o[1] >>> 16;
  117. 		o[1] &= 0xffff;
  118.  
  119. 		o[1] += m[2] * n[2];
  120. 		o[0] += o[1] >>> 16;
  121. 		o[1] &= 0xffff;
  122.  
  123. 		o[1] += m[3] * n[1];
  124. 		o[0] += o[1] >>> 16;
  125. 		o[1] &= 0xffff;
  126.  
  127. 		o[0] += (m[0] * n[3]) + (m[1] * n[2]) + (m[2] * n[1]) + (m[3] * n[0]);
  128. 		o[0] &= 0xffff;
  129.  
  130. 		return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];
  131. 	}
  132.  
  133.  
  134. enter input (stdin)
  135. 8e40986c-c4e3-43b5-9565-59a5a8fa06c5
  136. JavaScript
  137. more options
  138.  
  139.  
  140.  
  141. 	function _x64Rotl(m, n) {
  142. 		//
  143. 		// Given a 64bit int (as an array of two 32bit ints) and an int
  144. 		// representing a number of bit positions, returns the 64bit int (as an
  145. 		// array of two 32bit ints) rotated left by that number of positions.
  146. 		//
  147.  
  148. 		n %= 64;
  149.  
  150. 		if (n === 32) {
  151. 			return [m[1], m[0]];
  152. 		}
  153.  
  154. 		else if (n < 32) {
  155. 			return [(m[0] << n) | (m[1] >>> (32 - n)), (m[1] << n) | (m[0] >>> (32 - n))];
  156. 		}
  157.  
  158. 		else {
  159. 			n -= 32;
  160. 			return [(m[1] << n) | (m[0] >>> (32 - n)), (m[0] << n) | (m[1] >>> (32 - n))];
  161. 		}
  162. 	}
  163.  
  164.  
  165. 	function _x64LeftShift(m, n) {
  166. 		//
  167. 		// Given a 64bit int (as an array of two 32bit ints) and an int
  168. 		// representing a number of bit positions, returns the 64bit int (as an
  169. 		// array of two 32bit ints) shifted left by that number of positions.
  170. 		//
  171.  
  172. 		n %= 64;
  173.  
  174. 		if (n === 0) {
  175. 			return m;
  176. 		}
  177.  
  178. 		else if (n < 32) {
  179. 			return [(m[0] << n) | (m[1] >>> (32 - n)), m[1] << n];
  180. 		}
  181.  
  182. 		else {
  183. 			return [m[1] << (n - 32), 0];
  184. 		}
  185. 	}
  186.  
  187.  
  188. 	function _x64Xor(m, n) {
  189. 		//
  190. 		// Given two 64bit ints (as an array of two 32bit ints) returns the two
  191. 		// xored together as a 64bit int (as an array of two 32bit ints).
  192. 		//
  193.  
  194. 		return [m[0] ^ n[0], m[1] ^ n[1]];
  195. 	}
  196.  
  197.  
  198. 	function _x64Fmix(h) {
  199. 		//
  200. 		// Given a block, returns murmurHash3's final x64 mix of that block.
  201. 		// (`[0, h[0] >>> 1]` is a 33 bit unsigned right shift. This is the
  202. 		// only place where we need to right shift 64bit ints.)
  203. 		//
  204.  
  205. 		h = _x64Xor(h, [0, h[0] >>> 1]);
  206. 		h = _x64Multiply(h, [0xff51afd7, 0xed558ccd]);
  207. 		h = _x64Xor(h, [0, h[0] >>> 1]);
  208. 		h = _x64Multiply(h, [0xc4ceb9fe, 0x1a85ec53]);
  209. 		h = _x64Xor(h, [0, h[0] >>> 1]);
  210.  
  211. 		return h;
  212. 	}
  213.  
  214.  
  215.  
  216.  
  217. 	// PUBLIC FUNCTIONS
  218. 	// ----------------
  219.  
  220. 	library.x86.hash32 = function (key, seed) {
  221. 		//
  222. 		// Given a string and an optional seed as an int, returns a 32 bit hash
  223. 		// using the x86 flavor of MurmurHash3, as an unsigned int.
  224. 		//
  225.  
  226. 		key = key || '';
  227. 		seed = seed || 0;
  228.  
  229. 		var remainder = key.length % 4;
  230. 		var bytes = key.length - remainder;
  231.  
  232. 		var h1 = seed;
  233.  
  234. 		var k1 = 0;
  235.  
  236. 		var c1 = 0xcc9e2d51;
  237. 		var c2 = 0x1b873593;
  238.  
  239. 		for (var i = 0; i < bytes; i = i + 4) {
  240. 			k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);
  241.  
  242. 			k1 = _x86Multiply(k1, c1);
  243. 			k1 = _x86Rotl(k1, 15);
  244. 			k1 = _x86Multiply(k1, c2);
  245.  
  246. 			h1 ^= k1;
  247. 			h1 = _x86Rotl(h1, 13);
  248. 			h1 = _x86Multiply(h1, 5) + 0xe6546b64;
  249. 		}
  250.  
  251. 		k1 = 0;
  252.  
  253. 		switch (remainder) {
  254. 			case 3:
  255. 				k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
  256.  
  257. 			case 2:
  258. 				k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
  259.  
  260. 			case 1:
  261. 				k1 ^= (key.charCodeAt(i) & 0xff);
  262. 				k1 = _x86Multiply(k1, c1);
  263. 				k1 = _x86Rotl(k1, 15);
  264. 				k1 = _x86Multiply(k1, c2);
  265. 				h1 ^= k1;
  266. 		}
  267.  
  268. 		h1 ^= key.length;
  269. 		h1 = _x86Fmix(h1);
  270.  
  271. 		return h1 >>> 0;
  272. 	};
  273.  
  274.  
  275. 	library.x86.hash128 = function (key, seed) {
  276. 		//
  277. 		// Given a string and an optional seed as an int, returns a 128 bit
  278. 		// hash using the x86 flavor of MurmurHash3, as an unsigned hex.
  279. 		//
  280.  
  281. 		key = key || '';
  282. 		seed = seed || 0;
  283.  
  284. 		var remainder = key.length % 16;
  285. 		var bytes = key.length - remainder;
  286.  
  287. 		var h1 = seed;
  288. 		var h2 = seed;
  289. 		var h3 = seed;
  290. 		var h4 = seed;
  291.  
  292. 		var k1 = 0;
  293. 		var k2 = 0;
  294. 		var k3 = 0;
  295. 		var k4 = 0;
  296.  
  297. 		var c1 = 0x239b961b;
  298. 		var c2 = 0xab0e9789;
  299. 		var c3 = 0x38b34ae5;
  300. 		var c4 = 0xa1e38b93;
  301.  
  302. 		for (var i = 0; i < bytes; i = i + 16) {
  303. 			k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);
  304. 			k2 = ((key.charCodeAt(i + 4) & 0xff)) | ((key.charCodeAt(i + 5) & 0xff) << 8) | ((key.charCodeAt(i + 6) & 0xff) << 16) | ((key.charCodeAt(i + 7) & 0xff) << 24);
  305. 			k3 = ((key.charCodeAt(i + 8) & 0xff)) | ((key.charCodeAt(i + 9) & 0xff) << 8) | ((key.charCodeAt(i + 10) & 0xff) << 16) | ((key.charCodeAt(i + 11) & 0xff) << 24);
  306. 			k4 = ((key.charCodeAt(i + 12) & 0xff)) | ((key.charCodeAt(i + 13) & 0xff) << 8) | ((key.charCodeAt(i + 14) & 0xff) << 16) | ((key.charCodeAt(i + 15) & 0xff) << 24);
  307.  
  308. 			k1 = _x86Multiply(k1, c1);
  309. 			k1 = _x86Rotl(k1, 15);
  310. 			k1 = _x86Multiply(k1, c2);
  311. 			h1 ^= k1;
  312.  
  313. 			h1 = _x86Rotl(h1, 19);
  314. 			h1 += h2;
  315. 			h1 = _x86Multiply(h1, 5) + 0x561ccd1b;
  316.  
  317. 			k2 = _x86Multiply(k2, c2);
  318. 			k2 = _x86Rotl(k2, 16);
  319. 			k2 = _x86Multiply(k2, c3);
  320. 			h2 ^= k2;
  321.  
  322. 			h2 = _x86Rotl(h2, 17);
  323. 			h2 += h3;
  324. 			h2 = _x86Multiply(h2, 5) + 0x0bcaa747;
  325.  
  326. 			k3 = _x86Multiply(k3, c3);
  327. 			k3 = _x86Rotl(k3, 17);
  328. 			k3 = _x86Multiply(k3, c4);
  329. 			h3 ^= k3;
  330.  
  331. 			h3 = _x86Rotl(h3, 15);
  332. 			h3 += h4;
  333. 			h3 = _x86Multiply(h3, 5) + 0x96cd1c35;
  334.  
  335. 			k4 = _x86Multiply(k4, c4);
  336. 			k4 = _x86Rotl(k4, 18);
  337. 			k4 = _x86Multiply(k4, c1);
  338. 			h4 ^= k4;
  339.  
  340. 			h4 = _x86Rotl(h4, 13);
  341. 			h4 += h1;
  342. 			h4 = _x86Multiply(h4, 5) + 0x32ac3b17;
  343. 		}
  344.  
  345. 		k1 = 0;
  346. 		k2 = 0;
  347. 		k3 = 0;
  348. 		k4 = 0;
  349.  
  350. 		switch (remainder) {
  351. 			case 15:
  352. 				k4 ^= key.charCodeAt(i + 14) << 16;
  353.  
  354. 			case 14:
  355. 				k4 ^= key.charCodeAt(i + 13) << 8;
  356.  
  357. 			case 13:
  358. 				k4 ^= key.charCodeAt(i + 12);
  359. 				k4 = _x86Multiply(k4, c4);
  360. 				k4 = _x86Rotl(k4, 18);
  361. 				k4 = _x86Multiply(k4, c1);
  362. 				h4 ^= k4;
  363.  
  364. 			case 12:
  365. 				k3 ^= key.charCodeAt(i + 11) << 24;
  366.  
  367. 			case 11:
  368. 				k3 ^= key.charCodeAt(i + 10) << 16;
  369.  
  370. 			case 10:
  371. 				k3 ^= key.charCodeAt(i + 9) << 8;
  372.  
  373. 			case 9:
  374. 				k3 ^= key.charCodeAt(i + 8);
  375. 				k3 = _x86Multiply(k3, c3);
  376. 				k3 = _x86Rotl(k3, 17);
  377. 				k3 = _x86Multiply(k3, c4);
  378. 				h3 ^= k3;
  379.  
  380. 			case 8:
  381. 				k2 ^= key.charCodeAt(i + 7) << 24;
  382.  
  383. 			case 7:
  384. 				k2 ^= key.charCodeAt(i + 6) << 16;
  385.  
  386. 			case 6:
  387. 				k2 ^= key.charCodeAt(i + 5) << 8;
  388.  
  389. 			case 5:
  390. 				k2 ^= key.charCodeAt(i + 4);
  391. 				k2 = _x86Multiply(k2, c2);
  392. 				k2 = _x86Rotl(k2, 16);
  393. 				k2 = _x86Multiply(k2, c3);
  394. 				h2 ^= k2;
  395.  
  396. 			case 4:
  397. 				k1 ^= key.charCodeAt(i + 3) << 24;
  398.  
  399. 			case 3:
  400. 				k1 ^= key.charCodeAt(i + 2) << 16;
  401.  
  402. 			case 2:
  403. 				k1 ^= key.charCodeAt(i + 1) << 8;
  404.  
  405. 			case 1:
  406. 				k1 ^= key.charCodeAt(i);
  407. 				k1 = _x86Multiply(k1, c1);
  408. 				k1 = _x86Rotl(k1, 15);
  409. 				k1 = _x86Multiply(k1, c2);
  410. 				h1 ^= k1;
  411. 		}
  412.  
  413. 		h1 ^= key.length;
  414. 		h2 ^= key.length;
  415. 		h3 ^= key.length;
  416. 		h4 ^= key.length;
  417.  
  418. 		h1 += h2;
  419. 		h1 += h3;
  420. 		h1 += h4;
  421. 		h2 += h1;
  422. 		h3 += h1;
  423. 		h4 += h1;
  424.  
  425. 		h1 = _x86Fmix(h1);
  426. 		h2 = _x86Fmix(h2);
  427. 		h3 = _x86Fmix(h3);
  428. 		h4 = _x86Fmix(h4);
  429.  
  430. 		h1 += h2;
  431. 		h1 += h3;
  432. 		h1 += h4;
  433. 		h2 += h1;
  434. 		h3 += h1;
  435. 		h4 += h1;
  436.  
  437. 		return ("00000000" + (h1 >>> 0).toString(16)).slice(-8) + ("00000000" + (h2 >>> 0).toString(16)).slice(-8) + ("00000000" + (h3 >>> 0).toString(16)).slice(-8) + ("00000000" + (h4 >>> 0).toString(16)).slice(-8);
  438. 	};
  439.  
  440.  
  441. 	library.x64.hash128 = function (key, seed) {
  442. 		//
  443. 		// Given a string and an optional seed as an int, returns a 128 bit
  444. 		// hash using the x64 flavor of MurmurHash3, as an unsigned hex.
  445. 		//
  446.  
  447. 		key = key || '';
  448. 		seed = seed || 0;
  449.  
  450. 		var remainder = key.length % 16;
  451. 		var bytes = key.length - remainder;
  452.  
  453. 		var h1 = [0, seed];
  454. 		var h2 = [0, seed];
  455.  
  456. 		var k1 = [0, 0];
  457. 		var k2 = [0, 0];
  458.  
  459. 		var c1 = [0x87c37b91, 0x114253d5];
  460. 		var c2 = [0x4cf5ad43, 0x2745937f];
  461.  
  462. 		for (var i = 0; i < bytes; i = i + 16) {
  463. 			k1 = [((key.charCodeAt(i + 4) & 0xff)) | ((key.charCodeAt(i + 5) & 0xff) << 8) | ((key.charCodeAt(i + 6) & 0xff) << 16) | ((key.charCodeAt(i + 7) & 0xff) << 24), ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24)];
  464. 			k2 = [((key.charCodeAt(i + 12) & 0xff)) | ((key.charCodeAt(i + 13) & 0xff) << 8) | ((key.charCodeAt(i + 14) & 0xff) << 16) | ((key.charCodeAt(i + 15) & 0xff) << 24), ((key.charCodeAt(i + 8) & 0xff)) | ((key.charCodeAt(i + 9) & 0xff) << 8) | ((key.charCodeAt(i + 10) & 0xff) << 16) | ((key.charCodeAt(i + 11) & 0xff) << 24)];
  465.  
  466. 			k1 = _x64Multiply(k1, c1);
  467. 			k1 = _x64Rotl(k1, 31);
  468. 			k1 = _x64Multiply(k1, c2);
  469. 			h1 = _x64Xor(h1, k1);
  470.  
  471. 			h1 = _x64Rotl(h1, 27);
  472. 			h1 = _x64Add(h1, h2);
  473. 			h1 = _x64Add(_x64Multiply(h1, [0, 5]), [0, 0x52dce729]);
  474.  
  475. 			k2 = _x64Multiply(k2, c2);
  476. 			k2 = _x64Rotl(k2, 33);
  477. 			k2 = _x64Multiply(k2, c1);
  478. 			h2 = _x64Xor(h2, k2);
  479.  
  480. 			h2 = _x64Rotl(h2, 31);
  481. 			h2 = _x64Add(h2, h1);
  482. 			h2 = _x64Add(_x64Multiply(h2, [0, 5]), [0, 0x38495ab5]);
  483. 		}
  484.  
  485. 		k1 = [0, 0];
  486. 		k2 = [0, 0];
  487.  
  488. 		switch(remainder) {
  489. 			case 15:
  490. 				k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 14)], 48));
  491.  
  492. 			case 14:
  493. 				k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 13)], 40));
  494.  
  495. 			case 13:
  496. 				k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 12)], 32));
  497.  
  498. 			case 12:
  499. 				k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 11)], 24));
  500.  
  501. 			case 11:
  502. 				k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 10)], 16));
  503.  
  504. 			case 10:
  505. 				k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 9)], 8));
  506.  
  507. 			case 9:
  508. 				k2 = _x64Xor(k2, [0, key.charCodeAt(i + 8)]);
  509. 				k2 = _x64Multiply(k2, c2);
  510. 				k2 = _x64Rotl(k2, 33);
  511. 				k2 = _x64Multiply(k2, c1);
  512. 				h2 = _x64Xor(h2, k2);
  513.  
  514. 			case 8:
  515. 				k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 7)], 56));
  516.  
  517. 			case 7:
  518. 				k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 6)], 48));
  519.  
  520. 			case 6:
  521. 				k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 5)], 40));
  522.  
  523. 			case 5:
  524. 				k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 4)], 32));
  525.  
  526. 			case 4:
  527. 				k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 3)], 24));
  528.  
  529. 			case 3:
  530. 				k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 2)], 16));
  531.  
  532. 			case 2:
  533. 				k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 1)], 8));
  534.  
  535. 			case 1:
  536. 				k1 = _x64Xor(k1, [0, key.charCodeAt(i)]);
  537. 				k1 = _x64Multiply(k1, c1);
  538. 				k1 = _x64Rotl(k1, 31);
  539. 				k1 = _x64Multiply(k1, c2);
  540. 				h1 = _x64Xor(h1, k1);
  541. 		}
  542.  
  543. 		h1 = _x64Xor(h1, [0, key.length]);
  544. 		h2 = _x64Xor(h2, [0, key.length]);
  545.  
  546. 		h1 = _x64Add(h1, h2);
  547. 		h2 = _x64Add(h2, h1);
  548.  
  549. 		h1 = _x64Fmix(h1);
  550. 		h2 = _x64Fmix(h2);
  551.  
  552. 		h1 = _x64Add(h1, h2);
  553. 		h2 = _x64Add(h2, h1);
  554.  
  555. 		return ("00000000" + (h1[0] >>> 0).toString(16)).slice(-8) + ("00000000" + (h1[1] >>> 0).toString(16)).slice(-8) + ("00000000" + (h2[0] >>> 0).toString(16)).slice(-8) + ("00000000" + (h2[1] >>> 0).toString(16)).slice(-8);
  556. 	};
  557.  
  558.  
  559.  
  560.  
  561. 	// INITIALIZATION
  562. 	// --------------
  563.  
  564. 	// Export murmurHash3 for CommonJS, either as an AMD module or just as part
  565. 	// of the global object.
  566. 	if (typeof exports !== 'undefined') {
  567. 		if (typeof module !== 'undefined' && module.exports) {
  568. 			exports = module.exports = library;
  569. 		}
  570.  
  571. 		exports.murmurHash3 = library;
  572. 	}
  573.  
  574. 	else if (typeof define === 'function' && define.amd) {
  575. 		define([], function() {
  576. 			return library;
  577. 		});
  578. 	}
  579.  
  580. 	else {
  581. 		// Use murmurHash3.noConflict to restore `murmurHash3` back to its
  582. 		// original value. Returns a reference to the library object, to allow
  583. 		// it to be used under a different name.
  584. 		library._murmurHash3 = root.murmurHash3
  585.  
  586. 		library.noConflict = function () {
  587. 			root.murmurHash3 = library._murmurHash3;
  588. 			library._murmurHash3 = undefined;
  589. 			library.noConflict = undefined;
  590.  
  591. 			return library;
  592. 		};
  593.  
  594. 		root.murmurHash3 = library;
  595. 	}
  596. })(this);
Runtime error #stdin #stdout #stderr 0.27s 2576384KB
comments (?)
stdin
copy 
8e40986c-c4e3-43b5-9565-59a5a8fa06c5
stdout
copy 
Standard output is empty
stderr
copy 
js: "prog.js", line 134: missing ; before statement
js: enter input (stdin)
js: ...........^
js: "prog.js", line 135: missing ; before statement
js: 8e40986c-c4e3-43b5-9565-59a5a8fa06c5
js: ..................^
js: "prog.js", line 137: missing ; before statement
js: more options
js: ...........^
js: "prog.js", line 141: missing ; before statement
js: 	function _x64Rotl(m, n) {
js: .........................^
js: "prog.js", line 148: syntax error
js: 		n %= 64;
js: .....^
js: "prog.js", line 165: missing ) in parenthetical
js: 	function _x64LeftShift(m, n) {
js: .........^
js: "prog.js", line 165: missing ; before statement
js: 	function _x64LeftShift(m, n) {
js: ..............................^
js: "prog.js", line 172: syntax error
js: 		n %= 64;
js: .....^
js: "prog.js", line 175: invalid return
js: 			return m;
js: .........^
js: "prog.js", line 179: invalid return
js: 			return [(m[0] << n) | (m[1] >>> (32 - n)), m[1] << n];
js: .........^
js: "prog.js", line 183: invalid return
js: 			return [m[1] << (n - 32), 0];
js: .........^
js: "prog.js", line 185: syntax error
js: 	}
js: .^
js: "prog.js", line 188: missing ; before statement
js: 	function _x64Xor(m, n) {
js: ........................^
js: "prog.js", line 195: syntax error
js: 	}
js: .^
js: "prog.js", line 198: missing ; before statement
js: 	function _x64Fmix(h) {
js: ......................^
js: "prog.js", line 205: syntax error
js: 		h = _x64Xor(h, [0, h[0] >>> 1]);
js: .....^
js: "prog.js", line 211: invalid return
js: 		return h;
js: ........^
js: "prog.js", line 212: syntax error
js: 	}
js: .^
js: "prog.js", line 220: syntax error
js: 	library.x86.hash32 = function (key, seed) {
js: .........^
js: "prog.js", line 226: syntax error
js: 		key = key || '';
js: .......^
js: "prog.js", line 271: invalid return
js: 		return h1 >>> 0;
js: ........^
js: "prog.js", line 272: syntax error
js: 	};
js: .^
js: "prog.js", line 596: syntax error
js: })(this);
js: ^
js: "prog.js", line 1: Compilation produced 23 syntax errors.
https://ideone.com/HZaSCb
language:
JavaScript (rhino 1.7.9)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!