API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 14th, 2015
294
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.01 KB | None | 0 0
raw download clone embed print report
  1. var baz = function() {
  2. var context = {};
  3. /** @type {number} */
  4. var x = 1;
  5. /** @type {number} */
  6. var k = 2;
  7. /** @type {number} */
  8. var o = 10;
  9. /** @type {number} */
  10. var q = 14;
  11. /** @type {number} */
  12. var B = 0;
  13. /** @type {number} */
  14. var r = 4;
  15. /** @type {number} */
  16. var b = 4096;
  17. /** @type {number} */
  18. var base = 16;
  19. /** @type {number} */
  20. var y = 258;
  21. /** @type {number} */
  22. var padLength = 23;
  23. /** @type {number} */
  24. var IMAGE = 0;
  25. /** @type {number} */
  26. var PREVIEW = 1;
  27. /** @type {number} */
  28. var bufferLength = 6;
  29. /** @type {number} */
  30. var fn = 50;
  31. /** @type {number} */
  32. var c = 4;
  33. /** @type {number} */
  34. var z = 2 + 9E5 / fn;
  35. var that = cgd();
  36. /**
  37. * @param {Object} data
  38. * @param {boolean} el
  39. * @param {?} array
  40. * @param {?} opt_attributes
  41. * @param {number} e
  42. * @return {?}
  43. */
  44. context._eke = function(data, el, array, opt_attributes, e) {
  45. /** @type {Uint8Array} */
  46. that._hhj = new Uint8Array(array);
  47. /** @type {number} */
  48. that._hhk = e;
  49. /** @type {Uint8Array} */
  50. that._hhp = new Uint8Array(data);
  51. /** @type {number} */
  52. that._hhq = 0;
  53. that._hhl = opt_attributes;
  54. /** @type {boolean} */
  55. that._hhs = el;
  56. /** @type {number} */
  57. that._hie = 0;
  58. /** @type {number} */
  59. that._hic = 0;
  60. /** @type {number} */
  61. that._hhn = 0;
  62. /** @type {number} */
  63. that._hho = 0;
  64. /** @type {number} */
  65. that._hhu = 0;
  66. /** @type {number} */
  67. that._hhv = 0;
  68. /** @type {number} */
  69. that._hig = 0;
  70. filter(that);
  71. el -= that._hhs;
  72. /** @type {null} */
  73. that._hhj = null;
  74. /** @type {null} */
  75. that._hhp = null;
  76. return el;
  77. };
  78. /** @type {function (Object, boolean, ?, ?, number): ?} */
  79. var j = context._eke;
  80. /**
  81. * @param {?} that
  82. * @return {undefined}
  83. */
  84. var filter = function(that) {
  85. var value;
  86. var val;
  87. var node;
  88. /** @type {number} */
  89. var idx = 0;
  90. /** @type {number} */
  91. var property = 0;
  92. /** @type {number} */
  93. var p = 0;
  94. /** @type {number} */
  95. var failuresLink = 0;
  96. /** @type {number} */
  97. var pl = 0;
  98. /** @type {number} */
  99. var html = 0;
  100. /** @type {number} */
  101. var wanted = 0;
  102. /** @type {number} */
  103. var k = 0;
  104. /** @type {number} */
  105. var bulk = 0;
  106. /** @type {number} */
  107. var type = 0;
  108. /** @type {number} */
  109. var index = 0;
  110. /** @type {number} */
  111. var from = 0;
  112. /** @type {number} */
  113. var delta = 0;
  114. /** @type {number} */
  115. var current = 0;
  116. /** @type {number} */
  117. var error = 0;
  118. /** @type {number} */
  119. var ret = 0;
  120. /** @type {number} */
  121. var params = 0;
  122. /** @type {number} */
  123. var i = 0;
  124. /** @type {number} */
  125. var err = 0;
  126. /** @type {null} */
  127. var response = null;
  128. /** @type {null} */
  129. var a = null;
  130. /** @type {null} */
  131. var split = null;
  132. /** @type {number} */
  133. that._hif = 1;
  134. if (that._hir === null) {
  135. /** @type {Uint32Array} */
  136. that._hir = new Uint32Array(new ArrayBuffer(that._hif * 1E5 * 4));
  137. }
  138. /** @type {boolean} */
  139. var I = true;
  140. for (;I;) {
  141. value = log(that);
  142. if (value == 23) {
  143. return;
  144. }
  145. value = log(that);
  146. value = log(that);
  147. value = log(that);
  148. value = log(that);
  149. value = log(that);
  150. that._hig++;
  151. value = log(that);
  152. value = log(that);
  153. value = log(that);
  154. value = log(that);
  155. value = extend(that);
  156. if (value != 0) {
  157. /** @type {boolean} */
  158. that._hia = true;
  159. } else {
  160. /** @type {boolean} */
  161. that._hia = false;
  162. }
  163. if (false) {
  164. }
  165. /** @type {number} */
  166. that._hii = 0;
  167. value = log(that);
  168. /** @type {number} */
  169. that._hii = that._hii << 8 | value & 255;
  170. value = log(that);
  171. /** @type {number} */
  172. that._hii = that._hii << 8 | value & 255;
  173. value = log(that);
  174. /** @type {number} */
  175. that._hii = that._hii << 8 | value & 255;
  176. /** @type {number} */
  177. idx = 0;
  178. for (;idx < 16;idx++) {
  179. value = extend(that);
  180. if (value == 1) {
  181. /** @type {boolean} */
  182. that._hiw[idx] = true;
  183. } else {
  184. /** @type {boolean} */
  185. that._hiw[idx] = false;
  186. }
  187. }
  188. /** @type {number} */
  189. idx = 0;
  190. for (;idx < 256;idx++) {
  191. /** @type {boolean} */
  192. that._hiu[idx] = false;
  193. }
  194. /** @type {number} */
  195. idx = 0;
  196. for (;idx < 16;idx++) {
  197. if (that._hiw[idx]) {
  198. /** @type {number} */
  199. property = 0;
  200. for (;property < 16;property++) {
  201. value = extend(that);
  202. if (value == 1) {
  203. /** @type {boolean} */
  204. that._hiu[idx * 16 + property] = true;
  205. }
  206. }
  207. }
  208. }
  209. isUndefinedOrNull(that);
  210. failuresLink = that._hit + 2;
  211. pl = callback(3, that);
  212. html = callback(15, that);
  213. /** @type {number} */
  214. idx = 0;
  215. for (;idx < html;idx++) {
  216. /** @type {number} */
  217. property = 0;
  218. for (;true;) {
  219. value = extend(that);
  220. if (value == 0) {
  221. break;
  222. }
  223. property++;
  224. }
  225. /** @type {number} */
  226. that._hje[idx] = property & 255;
  227. }
  228. /** @type {Uint8Array} */
  229. var result = new Uint8Array(new ArrayBuffer(bufferLength));
  230. var res;
  231. var j;
  232. /** @type {number} */
  233. j = 0;
  234. for (;j < pl;j++) {
  235. /** @type {number} */
  236. result[j] = j;
  237. }
  238. /** @type {number} */
  239. idx = 0;
  240. for (;idx < html;idx++) {
  241. j = that._hje[idx];
  242. res = result[j];
  243. for (;j > 0;) {
  244. result[j] = result[j - 1];
  245. j--;
  246. }
  247. result[0] = res;
  248. that._hjc[idx] = res;
  249. }
  250. /** @type {number} */
  251. p = 0;
  252. for (;p < pl;p++) {
  253. current = callback(5, that);
  254. /** @type {number} */
  255. idx = 0;
  256. for (;idx < failuresLink;idx++) {
  257. for (;true;) {
  258. value = extend(that);
  259. if (value == 0) {
  260. break;
  261. }
  262. value = extend(that);
  263. if (value == 0) {
  264. current++;
  265. } else {
  266. current--;
  267. }
  268. }
  269. that._eww[p][idx] = current;
  270. }
  271. }
  272. /** @type {number} */
  273. p = 0;
  274. for (;p < pl;p++) {
  275. /** @type {number} */
  276. val = 32;
  277. /** @type {number} */
  278. node = 0;
  279. /** @type {number} */
  280. idx = 0;
  281. for (;idx < failuresLink;idx++) {
  282. if (that._eww[p][idx] > node) {
  283. node = that._eww[p][idx];
  284. }
  285. if (that._eww[p][idx] < val) {
  286. val = that._eww[p][idx];
  287. }
  288. }
  289. clone(that._hjf[p], that._clt[p], that._hjh[p], that._eww[p], val, node, failuresLink);
  290. that._hji[p] = val;
  291. }
  292. wanted = that._hit + 1;
  293. /** @type {number} */
  294. k = -1;
  295. /** @type {number} */
  296. bulk = 0;
  297. /** @type {number} */
  298. idx = 0;
  299. for (;idx <= 255;idx++) {
  300. /** @type {number} */
  301. that._him[idx] = 0;
  302. }
  303. var d;
  304. var px;
  305. var s;
  306. /** @type {number} */
  307. s = b - 1;
  308. /** @type {number} */
  309. d = 256 / base - 1;
  310. for (;d >= 0;d--) {
  311. /** @type {number} */
  312. px = base - 1;
  313. for (;px >= 0;px--) {
  314. /** @type {number} */
  315. that._hiy[s] = d * base + px & 255;
  316. s--;
  317. }
  318. /** @type {number} */
  319. that._hja[d] = s + 1;
  320. }
  321. /** @type {number} */
  322. index = 0;
  323. if (bulk == 0) {
  324. k++;
  325. /** @type {number} */
  326. bulk = fn;
  327. i = that._hjc[k];
  328. err = that._hji[i];
  329. response = that._hjf[i];
  330. split = that._hjh[i];
  331. a = that._clt[i];
  332. }
  333. bulk--;
  334. error = err;
  335. ret = callback(error, that);
  336. for (;true;) {
  337. if (ret <= response[error]) {
  338. break;
  339. }
  340. error++;
  341. params = extend(that);
  342. /** @type {number} */
  343. ret = ret << 1 | params;
  344. }
  345. type = split[ret - a[error]];
  346. for (;true;) {
  347. if (type == wanted) {
  348. break;
  349. }
  350. if (type == IMAGE || type == PREVIEW) {
  351. /** @type {number} */
  352. from = -1;
  353. /** @type {number} */
  354. delta = 1;
  355. do {
  356. if (type == IMAGE) {
  357. /** @type {number} */
  358. from = from + (0 + 1) * delta;
  359. } else {
  360. if (type == PREVIEW) {
  361. /** @type {number} */
  362. from = from + (1 + 1) * delta;
  363. }
  364. }
  365. /** @type {number} */
  366. delta = delta * 2;
  367. if (bulk == 0) {
  368. k++;
  369. /** @type {number} */
  370. bulk = fn;
  371. i = that._hjc[k];
  372. err = that._hji[i];
  373. response = that._hjf[i];
  374. split = that._hjh[i];
  375. a = that._clt[i];
  376. }
  377. bulk--;
  378. error = err;
  379. ret = callback(error, that);
  380. for (;true;) {
  381. if (ret <= response[error]) {
  382. break;
  383. }
  384. error++;
  385. params = extend(that);
  386. /** @type {number} */
  387. ret = ret << 1 | params;
  388. }
  389. type = split[ret - a[error]];
  390. } while (type == IMAGE || type == PREVIEW);
  391. from++;
  392. value = that._hix[that._hiy[that._hja[0]] & 255];
  393. that._him[value & 255] += from;
  394. for (;from > 0;) {
  395. /** @type {number} */
  396. that._hir[index] = value & 255;
  397. index++;
  398. from--;
  399. }
  400. continue;
  401. } else {
  402. var key;
  403. var last;
  404. var n10;
  405. var n;
  406. /** @type {number} */
  407. n = type - 1;
  408. if (n < base) {
  409. key = that._hja[0];
  410. value = that._hiy[key + n];
  411. for (;n > 3;) {
  412. var e = key + n;
  413. that._hiy[e] = that._hiy[e - 1];
  414. that._hiy[e - 1] = that._hiy[e - 2];
  415. that._hiy[e - 2] = that._hiy[e - 3];
  416. that._hiy[e - 3] = that._hiy[e - 4];
  417. n -= 4;
  418. }
  419. for (;n > 0;) {
  420. that._hiy[key + n] = that._hiy[key + n - 1];
  421. n--;
  422. }
  423. that._hiy[key] = value;
  424. } else {
  425. /** @type {number} */
  426. last = Math.floor(n / base);
  427. /** @type {number} */
  428. n10 = n % base;
  429. key = that._hja[last] + n10;
  430. value = that._hiy[key];
  431. for (;key > that._hja[last];) {
  432. that._hiy[key] = that._hiy[key - 1];
  433. key--;
  434. }
  435. that._hja[last]++;
  436. for (;last > 0;) {
  437. that._hja[last]--;
  438. that._hiy[that._hja[last]] = that._hiy[that._hja[last - 1] + base - 1];
  439. last--;
  440. }
  441. that._hja[0]--;
  442. that._hiy[that._hja[0]] = value;
  443. if (that._hja[0] == 0) {
  444. /** @type {number} */
  445. s = b - 1;
  446. /** @type {number} */
  447. d = 256 / base - 1;
  448. for (;d >= 0;d--) {
  449. /** @type {number} */
  450. px = base - 1;
  451. for (;px >= 0;px--) {
  452. that._hiy[s] = that._hiy[that._hja[d] + px];
  453. s--;
  454. }
  455. /** @type {number} */
  456. that._hja[d] = s + 1;
  457. }
  458. }
  459. }
  460. that._him[that._hix[value & 255] & 255]++;
  461. /** @type {number} */
  462. that._hir[index] = that._hix[value & 255] & 255;
  463. index++;
  464. if (bulk == 0) {
  465. k++;
  466. /** @type {number} */
  467. bulk = fn;
  468. i = that._hjc[k];
  469. err = that._hji[i];
  470. response = that._hjf[i];
  471. split = that._hjh[i];
  472. a = that._clt[i];
  473. }
  474. bulk--;
  475. error = err;
  476. ret = callback(error, that);
  477. for (;true;) {
  478. if (ret <= response[error]) {
  479. break;
  480. }
  481. error++;
  482. params = extend(that);
  483. /** @type {number} */
  484. ret = ret << 1 | params;
  485. }
  486. type = split[ret - a[error]];
  487. continue;
  488. }
  489. }
  490. /** @type {number} */
  491. that._hhy = 0;
  492. /** @type {number} */
  493. that._hhx = 0;
  494. /** @type {number} */
  495. that._hip[0] = 0;
  496. /** @type {number} */
  497. idx = 1;
  498. for (;idx <= 256;idx++) {
  499. that._hip[idx] = that._him[idx - 1];
  500. }
  501. /** @type {number} */
  502. idx = 1;
  503. for (;idx <= 256;idx++) {
  504. that._hip[idx] += that._hip[idx - 1];
  505. }
  506. /** @type {number} */
  507. idx = 0;
  508. for (;idx < index;idx++) {
  509. /** @type {number} */
  510. value = that._hir[idx] & 255;
  511. that._hir[that._hip[value & 255]] |= idx << 8;
  512. that._hip[value & 255]++;
  513. }
  514. /** @type {number} */
  515. that._hij = that._hir[that._hii] >> 8;
  516. /** @type {number} */
  517. that._hio = 0;
  518. that._hij = that._hir[that._hij];
  519. /** @type {number} */
  520. that._hil = that._hij & 255;
  521. that._hij >>= 8;
  522. that._hio++;
  523. /** @type {number} */
  524. that._hjk = index;
  525. coerce(that);
  526. if (that._hio == that._hjk + 1 && that._hhy == 0) {
  527. /** @type {boolean} */
  528. I = true;
  529. } else {
  530. /** @type {boolean} */
  531. I = false;
  532. }
  533. }
  534. return;
  535. };
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!