Lines Matching refs:j
3964 var j = 0;
3967 while (length > j) {
3968 key = keys[j++];
6091 …rch,species,split,toPrimitive,toStringTag,unscopables'.split(','), j = 0; es6Symbols.length > j;) {
6092 wks(es6Symbols[j++]);
13640 for (var j = 0, jj = letterIndex / LIMIT | 0; j <= jj; j++) {
14730 var i, j;
14758 for (j = 0; j < typeFieldWidth; ++j) {
14766 for (j = 0; j < offsetFieldWidth; ++j) {
14770 for (j = 0; j < generationFieldWidth; ++j) {
16306 var j = 0;
16308 while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
16309 j++;
16312 if (j >= signatureLength) {
17831 var j = 0,
17838 inbuf = inbuf << 8 | rawBytes[j++] & 0xFF;
17882 j = bufferLength,
17889 buffer[j++] = rawBytes[i];
17896 buffer[j++] = rawBytes[i];
17900 buffer[j] = buffer[j - pixBytes] + rawBytes[i] & 0xFF;
17901 j++;
17908 buffer[j++] = prevRow[i] + rawBytes[i] & 0xFF;
17915 buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
17919 buffer[j] = (prevRow[i] + buffer[j - pixBytes] >> 1) + rawBytes[i] & 0xFF;
17920 j++;
17929 buffer[j++] = up + c;
17935 var left = buffer[j - pixBytes];
17958 buffer[j++] = left + c;
17960 buffer[j++] = up + c;
17962 buffer[j++] = upLeft + c;
18288 var i, j, q;
18319 for (j = currentSequenceLength - 1, q = code; j >= 0; j--) {
18320 currentSequence[j] = dictionaryValues[q];
18356 for (j = 0; j < currentSequenceLength; j++) {
18357 buffer[currentBufferLength++] = currentSequence[j];
19535 j,
19549 for (j = 0; j < width; j++) {
19550 row[j] = pixel = decoder.readBit(contexts, contextLabel);
19551 …l = (contextLabel & OLD_PIXEL_MASK) << 1 | (j + 3 < width ? row2[j + 3] << 11 : 0) | (j + 4 < widt…
19618 j,
19639 for (j = 0; j < width; j++) {
19640 if (useskip && skip[i][j]) {
19641 row[j] = 0;
19645 if (j >= sbb_left && j < sbb_right && i >= sbb_top) {
19650 j0 = j + changingTemplateX[k];
19663 j0 = j + templateX[k];
19680 row[j] = pixel;
19740 for (var j = 0; j < width; j++) {
19746 j0 = j + codingTemplateX[k];
19757 j0 = j + referenceTemplateX[k] - offsetX;
19767 row[j] = pixel;
19897 for (var j = 0; j < numberOfNewSymbols; i++, j++) {
19899 exportedSymbols.push(newSymbols[j]);
19918 for (var j = 0; j < width; j++) {
19919 row[j] = defaultPixelValue;
20108 var i, j, row;
20114 for (j = 0; j < regionWidth; j++) {
20115 row[j] = defaultPixelValue;
20176 for (j = bitsPerValue - 1; j >= 0; j--) {
20177 bit = grayScaleBitPlanes[j][mg][ng] ^ bit;
20178 patternIndex |= bit << j;
20190 for (j = 0; j < patternWidth; j++) {
20191 regionRow[x + j] |= patternRow[j];
20208 for (j = 0; j < patternWidth; j++) {
20209 regionX = x + j;
20212 regionRow[regionX] |= patternRow[j];
20297 var j = 0;
20299 while (j < searchPatternLength && searchPattern[j] === data[i + j]) {
20300 j++;
20303 if (j === searchPatternLength) {
20645 for (var j = 0; j < width; j++) {
20688 var i, j, mask, offset;
20696 for (j = 0; j < width; j++) {
20697 if (bitmap[i][j]) {
20719 for (j = 0; j < width; j++) {
20720 if (bitmap[i][j]) {
21176 j = void 0;
21202 for (j = 0; j < numberOfRepeats; j++) {
21988 j,
22003 for (j = 0; j < codeLengths[i]; j++) {
22293 var component, i, j, k, n;
22341 for (j = 0; j < v; j++) {
22343 decodeMcu(component, decodeFn, mcu, j, k);
22660 var i, j, l;
22722 for (j = 0; j < 64; j++) {
22723 z = dctZigZag[j];
22727 for (j = 0; j < 64; j++) {
22728 z = dctZigZag[j];
22799 for (j = 0; j < 16; j++, offset++) {
22800 codeLengthSum += codeLengths[j] = data[offset];
22805 for (j = 0; j < codeLengthSum; j++, offset++) {
22806 huffmanValues[j] = data[offset];
22921 var x, y, i, j, k;
22940 j = 0 | x * componentScaleX;
22941 xScaleBlockOffset[x] = (j & mask3LSB) << 3 | j & 7;
22945 j = 0 | y * componentScaleY;
22946 index = blocksPerScanline * (j & mask3LSB) | (j & 7) << 3;
22963 for (j = 0, k = 0; j < numComponents; j++, i++, k += 2) {
23169 for (var j = 0; j < tileHeight; j++) {
23356 j,
23385 j = position + 38;
23389 precision: (data[j] & 0x7F) + 1,
23390 isSigned: !!(data[j] & 0x80),
23391 XRsiz: data[j + 1],
23392 YRsiz: data[j + 2]
23394 j += 3;
23409 j = position + 2;
23410 sqcd = data[j++];
23437 while (j < length + position) {
23441 spqcd.epsilon = data[j++] >> 3;
23444 spqcd.epsilon = data[j] >> 3;
23445 spqcd.mu = (data[j] & 0x7) << 8 | data[j + 1];
23446 j += 2;
23466 j = position + 2;
23470 cqcc = data[j++];
23472 cqcc = (0, _util.readUint16)(data, j);
23473 j += 2;
23476 sqcd = data[j++];
23503 while (j < length + position) {
23507 spqcd.epsilon = data[j++] >> 3;
23510 spqcd.epsilon = data[j] >> 3;
23511 spqcd.mu = (data[j] & 0x7) << 8 | data[j + 1];
23512 j += 2;
23531 j = position + 2;
23532 var scod = data[j++];
23536 cod.progressionOrder = data[j++];
23537 cod.layersCount = (0, _util.readUint16)(data, j);
23538 j += 2;
23539 cod.multipleComponentTransform = data[j++];
23540 cod.decompositionLevelsCount = data[j++];
23541 cod.xcb = (data[j++] & 0xF) + 2;
23542 cod.ycb = (data[j++] & 0xF) + 2;
23543 var blockStyle = data[j++];
23550 cod.reversibleTransformation = data[j++];
23555 while (j < length + position) {
23556 var precinctsSize = data[j++];
23701 for (var j = 0, jj = tiles.length; j < jj; j++) {
23703 tile = tiles[j];
23764 var i, j, codeblock, precinctNumber;
23766 for (j = cby0; j < cby1; j++) {
23770 cby: j,
23772 tby0: codeblockHeight * j,
23774 tby1: codeblockHeight * (j + 1)
23801 if (j < precinct.cbyMin) {
23802 precinct.cbxMin = j;
23803 } else if (j > precinct.cbyMax) {
23804 precinct.cbyMax = j;
23809 cbyMin: j,
23811 cbyMax: j
23837 for (var j = 0, jj = codeblocks.length; j < jj; j++) {
23838 var codeblock = codeblocks[j];
24538 var j, jj, dataItem;
24540 for (j = 0, jj = data.length; j < jj; j++) {
24541 dataItem = data[j];
24549 for (j = 0, jj = data.length; j < jj; j++) {
24550 dataItem = data[j];
24559 for (j = 0; j < codingpasses; j++) {
24591 for (j = 0; j < blockHeight; j++) {
24645 for (var j = 0, jj = resolution.subbands.length; j < jj; j++) {
24657 var subband = resolution.subbands[j];
24707 j,
24726 for (j = 0; j < jj; j++, pos += alpha01) {
24727 y0 = y0items[j] + offset;
24728 y1 = y1items[j];
24729 y2 = y2items[j];
24735 for (j = 0; j < jj; j++, pos += alpha01) {
24736 y0 = y0items[j] + offset;
24737 y1 = y1items[j];
24738 y2 = y2items[j];
24747 for (j = 0, pos = 3; j < jj; j++, pos += 4) {
24748 out[pos] = y3items[j] + offset >> shift;
24757 for (pos = c, j = 0, jj = items.length; j < jj; j++) {
24758 out[pos] = items[j] + offset >> shift;
24804 reset: function TagTree_reset(i, j) {
24811 var index = i + j * level.width;
24820 j >>= 1;
24862 for (var j = 0, jj = items.length; j < jj; j++) {
24863 items[j] = defaultValue;
24878 reset: function InclusionTree_reset(i, j, stopValue) {
24883 var index = i + j * level.width;
24898 j >>= 1;
25040 for (var j = 0; j < width; j++) {
25041 var index = i0 * width + j;
25060 var sign = this.decodeSignBit(i, j, index);
25063 this.setNeighborsSignificance(i, j, index);
25144 for (var j = 0; j < width; j++) {
25145 for (var index = index0 + j; index < indexNext; index += width) {
25189 for (var j = 0; j < width; j++) {
25190 var index0 = indexBase + j;
25215 sign = this.decodeSignBit(i, j, index);
25218 this.setNeighborsSignificance(i, j, index);
25238 sign = this.decodeSignBit(i, j, index);
25241 this.setNeighborsSignificance(i, j, index);
25298 var i, j, k, l, u, v;
25303 for (j = 0; j < llWidth; j++, k++, l += 2) {
25395 var j, n, current, next;
25402 j = offset - 3;
25404 for (n = len + 4; n--; j += 2) {
25405 x[j] *= K_;
25408 j = offset - 2;
25409 current = delta * x[j - 1];
25411 for (n = len + 3; n--; j += 2) {
25412 next = delta * x[j + 1];
25413 x[j] = K * x[j] - current - next;
25416 j += 2;
25417 current = delta * x[j + 1];
25418 x[j] = K * x[j] - current - next;
25424 j = offset - 1;
25425 current = gamma * x[j - 1];
25427 for (n = len + 2; n--; j += 2) {
25428 next = gamma * x[j + 1];
25429 x[j] -= current + next;
25432 j += 2;
25433 current = gamma * x[j + 1];
25434 x[j] -= current + next;
25440 j = offset;
25441 current = beta * x[j - 1];
25443 for (n = len + 1; n--; j += 2) {
25444 next = beta * x[j + 1];
25445 x[j] -= current + next;
25448 j += 2;
25449 current = beta * x[j + 1];
25450 x[j] -= current + next;
25457 j = offset + 1;
25458 current = alpha * x[j - 1];
25460 for (n = len; n--; j += 2) {
25461 next = alpha * x[j + 1];
25462 x[j] -= current + next;
25465 j += 2;
25466 current = alpha * x[j + 1];
25467 x[j] -= current + next;
25488 var j, n;
25490 for (j = offset, n = len + 1; n--; j += 2) {
25491 x[j] -= x[j - 1] + x[j + 1] + 2 >> 2;
25494 for (j = offset + 1, n = len; n--; j += 2) {
25495 x[j] += x[j - 1] + x[j + 1] >> 1;
25549 j = 0,
25559 j = j + tmp + key[i % keyLength] & 0xFF;
25560 s[i] = s[j];
25561 s[j] = tmp;
25610 var i, j, n;
25634 for (j = 0; j < 16; ++j, i += 4) {
25635 w[j] = padded[i] | padded[i + 1] << 8 | padded[i + 2] << 16 | padded[i + 3] << 24;
25645 for (j = 0; j < 64; ++j) {
25646 if (j < 16) {
25648 g = j;
25649 } else if (j < 32) {
25651 g = 5 * j + 1 & 15;
25652 } else if (j < 48) {
25654 g = 3 * j + 5 & 15;
25657 g = 7 * j & 15;
25661 rotateArg = a + f + k[j] + w[g] | 0,
25662 rotate = r[j];
25810 var i, j, n;
25834 for (j = 0; j < 16; ++j) {
25835 w[j] = padded[i] << 24 | padded[i + 1] << 16 | padded[i + 2] << 8 | padded[i + 3];
25839 for (j = 16; j < 64; ++j) {
25840 w[j] = littleSigmaPrime(w[j - 2]) + w[j - 7] + littleSigma(w[j - 15]) + w[j - 16] | 0;
25854 for (j = 0; j < 64; ++j) {
25855 t1 = h + sigmaPrime(e) + ch(e, f, g) + k[j] + w[j];
25978 var i, j, n;
26028 for (j = 0; j < 16; ++j) {
26029 w[j].high = padded[i] << 24 | padded[i + 1] << 16 | padded[i + 2] << 8 | padded[i + 3];
26030 w[j].low = padded[i + 4] << 24 | padded[i + 5] << 16 | padded[i + 6] << 8 | padded[i + 7];
26034 for (j = 16; j < 80; ++j) {
26035 tmp3 = w[j];
26036 littleSigmaPrime(tmp3, w[j - 2], tmp2);
26037 tmp3.add(w[j - 7]);
26038 littleSigma(tmp1, w[j - 15], tmp2);
26040 tmp3.add(w[j - 16]);
26052 for (j = 0; j < 80; ++j) {
26058 t1.add(k[j]);
26059 t1.add(w[j]);
26177 for (var j = 0, k = this._keySize; j < 16; ++j, ++k) {
26178 state[j] ^= key[k];
26256 for (var j = 0; j < 16; ++j) {
26257 state[j] ^= key[j];
26349 for (var j = 0; j < 16; ++j) {
26350 plain[j] ^= iv[j];
26443 for (var j = 0; j < 16; ++j) {
26444 buffer[j] ^= iv[j];
26504 for (var j = 16, i = 1; j < b; ++i) {
26505 var t1 = result[j - 3];
26506 var t2 = result[j - 2];
26507 var t3 = result[j - 1];
26508 var t4 = result[j - 4];
26516 result[j] = t1 ^= result[j - 16];
26517 j++;
26518 result[j] = t2 ^= result[j - 16];
26519 j++;
26520 result[j] = t3 ^= result[j - 16];
26521 j++;
26522 result[j] = t4 ^= result[j - 16];
26523 j++;
26563 for (var j = 32, i = 1; j < b; ++i) {
26564 if (j % 32 === 16) {
26569 } else if (j % 32 === 0) {
26570 t1 = result[j - 3];
26571 t2 = result[j - 2];
26572 t3 = result[j - 1];
26573 t4 = result[j - 4];
26586 result[j] = t1 ^= result[j - 32];
26587 j++;
26588 result[j] = t2 ^= result[j - 32];
26589 j++;
26590 result[j] = t3 ^= result[j - 32];
26591 j++;
26592 result[j] = t4 ^= result[j - 32];
26593 j++;
26681 for (var j = 0, pos = 0; j < 64; j++, pos += arrayLength) {
26823 j,
26834 j = 0;
26837 hashData[i++] = defaultPasswordBytes[j++];
26840 for (j = 0, n = ownerPassword.length; j < n; ++j) {
26841 hashData[i++] = ownerPassword[j];
26849 for (j = 0, n = fileId.length; j < n; ++j) {
26850 hashData[i++] = fileId[j];
26864 for (j = 0; j < 50; ++j) {
26877 for (j = 0, n = fileId.length; j < n; ++j) {
26878 hashData[i++] = fileId[j];
26887 for (j = 1; j <= 19; ++j) {
26889 derivedKey[k] = encryptionKey[k] ^ j;
26896 for (j = 0, n = checkData.length; j < n; ++j) {
26897 if (userPassword[j] !== checkData[j]) {
26905 for (j = 0, n = checkData.length; j < n; ++j) {
26906 if (userPassword[j] !== checkData[j]) {
26918 j,
26926 j = 0;
26929 hashData[i++] = defaultPasswordBytes[j++];
26936 for (j = 0; j < 50; ++j) {
26948 for (j = 19; j >= 0; j--) {
26950 derivedKey[k] = hash[k] ^ j;
27206 for (var j = 0; j < w2; j++) {
27207 oldIndex = py + xScaled[j];
27631 var i, j;
27634 for (j = 0; j < numComps; j++) {
27635 scaled[j] = src[srcOffset++] * scale;
27641 for (j = 0; j < baseNumComps; j++) {
27642 baseBuf[pos++] = tinted[j] * 255;
27796 var j = srcOffset,
27800 var c = scale * src[j++];
27844 var j = srcOffset,
27848 dest[q++] = scale * src[j++];
27849 dest[q++] = scale * src[j++];
27850 dest[q++] = scale * src[j++];
29543 for (var j = 0, jj = originalInkLists[i].length; j < jj; j += 2) {
29545 x: xref.fetchIfRef(originalInkLists[i][j]),
29546 y: xref.fetchIfRef(originalInkLists[i][j + 1])
32057 for (var j = 0, jj = items.length; j < jj; j++) {
32058 if (typeof items[j] === 'string') {
32059 buildTextContentItem(items[j]);
32060 } else if ((0, _util.isNum)(items[j])) {
32062 advance = items[j] * textState.fontSize / 1000;
32305 for (var j = 0, jj = diffEncoding.length; j < jj; j++) {
32306 var data = xref.fetchIfRef(diffEncoding[j]);
32551 for (var j = 0, jj = glyphsData.length; j < jj; j++) {
32552 var glyphID = glyphsData[j++] << 8 | glyphsData[j];
32553 var code = j >> 1;
32570 var i, ii, j, jj, start, code, widths;
32582 for (j = 0, jj = code.length; j < jj; j++) {
32583 glyphsWidths[start++] = xref.fetchIfRef(code[j]);
32588 for (j = start; j <= code; j++) {
32589 glyphsWidths[j] = width;
32606 for (j = 0, jj = code.length; j < jj; j++) {
32607 …glyphsVMetrics[start++] = [xref.fetchIfRef(code[j++]), xref.fetchIfRef(code[j++]), xref.fetchIfRef…
32612 for (j = start; j <= code; j++) {
32613 glyphsVMetrics[j] = vmetric;
32624 j = firstChar;
32627 glyphsWidths[j++] = xref.fetchIfRef(widths[i]);
32778 for (var j = 0; j < diffLength; j++) {
32779 var diffEntry = entry[j];
32782 diffBuf[j] = diffEntry.name;
32784 diffBuf[j] = diffEntry.toString();
35019 var i, j, jj, table, tableName;
35060 for (j = tableOffsets[i], jj = tableOffsets[i + 1]; j < jj; j += 4) {
35061 var quad = (0, _util.readUint32)(file, j);
35434 var i, ii, j, jj;
35468 for (j = 1, jj = codes.length; j < jj; ++j) {
35469 if (codes[j] !== codes[j - 1] + 1) {
35481 for (j = 0, jj = codes.length; j < jj; ++j) {
35482 glyphsIds += string16(codes[j]);
35512 for (j = 1, jj = codes.length; j < jj; ++j) {
35513 if (codes[j] !== codes[j - 1] + 1) {
35514 end = range[0] + j - 1;
35517 code = codes[j];
35635 var i, ii, j, jj, str;
35641 for (j = 0, jj = str.length; j < jj; j++) {
35642 strBufUnicode.push(string16(str.charCodeAt(j)));
35659 for (j = 0, jj = strs.length; j < jj; j++) {
35660 str = strs[j];
35661 …var nameRecord = platforms[i] + encodings[i] + languages[i] + string16(j) + string16(str.length) +…
35890 for (var j = 0, jj = nameTable.length; j < jj; j++) {
35891 for (var k = 0, kk = nameTable[j].length; k < kk; k++) {
35892 var nameEntry = nameTable[j][k];
35983 var j, glyphId;
35986 for (j = 0; j < 256; j++) {
35994 charCode: j,
36040 for (j = 0; j < offsetsCount; j++) {
36051 for (j = start; j <= end; j++) {
36052 if (j === 0xFFFF) {
36056 glyphId = offsetIndex < 0 ? j : offsets[offsetIndex + j - start];
36059 charCode: j,
36068 for (j = 0; j < entryCount; j++) {
36070 var charCode = firstCode + j;
36175 j = 10,
36179 var endPoint = glyf[j] << 8 | glyf[j + 1];
36181 j += 2;
36184 var instructionsStart = j;
36185 var instructionsLength = glyf[j] << 8 | glyf[j + 1];
36187 j += 2 + instructionsLength;
36188 var instructionsEnd = j;
36192 var flag = glyf[j++];
36195 glyf[j - 1] = flag & 0x3F;
36202 var repeat = glyf[j++];
36212 var glyphDataLength = j + coordinatesLength;
36316 var i, j;
36318 for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) {
36319 var endOffset = itemDecode(locaData, j);
36345 itemEncode(locaData, j, writeOffset);
36352 for (i = 0, j = itemSize; i < numGlyphsOut; i++, j += itemSize) {
36353 itemEncode(locaData, j, simpleGlyph.length);
36437 var j = glyphNameIndexes[i];
36439 if (j < 258) {
36440 glyphNames.push(MacStandardGlyphOrdering[j]);
36444 glyphNames.push(customNames[j - 258]);
36520 for (var j = 0, jj = record.length; j < jj; j += 2) {
36538 j,
36562 for (j = 0; j < n; j++) {
36572 for (j = 0; j < n; j++) {
36583 for (j = 0; j < n; j++) {
36593 for (j = 0; j < n; j++) {
36745 for (var j = 0, jj = ttContext.functionsUsed.length; j < jj; j++) {
36746 if (j > maxFunctionDefs) {
36747 (0, _util.warn)('TT: invalid function id: ' + j);
36752 if (ttContext.functionsUsed[j] && !ttContext.functionsDefined[j]) {
36753 (0, _util.warn)('TT: undefined function: ' + j);
36763 var j, jj;
36765 for (j = 0, jj = content.length; j < jj; j++) {
36766 newLength += content[j].length;
36773 for (j = 0, jj = content.length; j < jj; j++) {
36774 result.set(content[j], pos);
36775 pos += content[j].length;
37481 j,
37485 j = 0;
37487 while (j < signatureLength && streamBytes[i + j] === signature[j]) {
37488 j++;
37491 if (j >= signatureLength) {
37492 i += j;
37782 for (var j = value.length - 1; j > 0; j--) {
37783 value[j] -= value[j - 1];
38302 for (var j = 0; j < offsetSize; ++j) {
38365 for (var j = 0; j < length;) {
38366 var value = data[j++];
38370 var q = data[j++];
38373 data[j - 2] = 139;
38374 data[j - 1] = 22;
38380 stack[stackSize] = (data[j] << 24 | data[j + 1] << 16) >> 16;
38381 j += 2;
38398 …ack[stackSize] = value < 251 ? (value - 247 << 8) + data[j] + 108 : -(value - 251 << 8) - data[j] …
38399 j++;
38402 … stack[stackSize] = (data[j] << 24 | data[j + 1] << 16 | data[j + 2] << 8 | data[j + 3]) / 65536;
38403 j += 4;
38407 j += state.hints + 7 >> 3;
38467 data[j - 1] = value === 1 ? 3 : 23;
38746 for (var j = start; j <= start + left; j++) {
38747 encoding[j] = gid++;
38799 for (var j = first; j < next; ++j) {
39341 for (var j = 0; j < length; j++) {
39342 var _char = name[j];
39348 sanitizedName[j] = _char;
39444 for (var j = 0, jj = types.length; j < jj; ++j) {
39445 var type = types[j];
39446 var value = values[j];
39655 for (var j = 0, jj = objects[i].length; j < jj; j++) {
39656 data.push(objects[i][j]);
47081 for (var j = 0, jj = ranges[i].end - ranges[i].start + 1; j < jj; j++) {
47082 ranges[i].ids[j] = getUshort(data, p + idOffset);
47143 for (var j = itemSize; j < loca.length; j += itemSize) {
47144 var endOffset = itemDecode(loca, j);
47269 var j, jj;
47271 for (j = 0; j < numberOfContours; j++) {
47296 for (j = 0; j < numberOfPoints; j++) {
47297 switch (points[j].flags & 0x12) {
47312 points[j].x = x;
47315 for (j = 0; j < numberOfPoints; j++) {
47316 switch (points[j].flags & 0x24) {
47331 points[j].y = y;
47356 for (j = 1, jj = contour.length; j < jj; j++) {
47357 if (contour[j].flags & 1) {
47358 lineTo(contour[j].x, contour[j].y);
47359 } else if (contour[j + 1].flags & 1) {
47360 quadraticCurveTo(contour[j].x, contour[j].y, contour[j + 1].x, contour[j + 1].y);
47361 j++;
47363 …quadraticCurveTo(contour[j].x, contour[j].y, (contour[j].x + contour[j + 1].x) / 2, (contour[j].y …
48345 j;
48354 for (i = discardNumber, j = 0; j < count; i++, j++) {
48356 decrypted[j] = value ^ r >> 8;
48370 var i, j;
48372 for (i = 0, j = 0; i < count; i++) {
48388 decrypted[j++] = value ^ r >> 8;
48393 return Array.prototype.slice.call(decrypted, discardNumber, j);
48657 for (var j = 0; j < size; j++) {
48993 for (var i = 0, j = 4; i < numComps; i++, j += 2) {
48995 components[i] = ci * scale * (decode[j + 1] - decode[j]) + decode[j];
49152 for (var j = 0; j <= 3; j++, q++) {
49153 var m = bRow[row][i] * bCol[col][j];
49475 var i, ii, j, jj;
49479 for (i = 0, j = 0, ii = coords.length; i < ii; i++) {
49481 coordsPacked[j++] = xy[0];
49482 coordsPacked[j++] = xy[1];
49489 for (i = 0, j = 0, ii = colors.length; i < ii; i++) {
49491 colorsPacked[j++] = c[0];
49492 colorsPacked[j++] = c[1];
49493 colorsPacked[j++] = c[2];
49504 for (j = 0, jj = ps.length; j < jj; j++) {
49505 ps[j] *= 2;
49506 cs[j] *= 3;
49648 for (var j = start, jj = arr.length; j < jj; ++j) {
49649 if (arr[j] !== value) {
49650 return j;
49654 return j;
49658 for (var j = start; j < end; ++j) {
49659 arr[j] = value;
49664 for (var i = start, j = end - 1; i < j; ++i, --j) {
49666 arr[i] = arr[j];
49667 arr[j] = temp;
49787 var j;
49789 for (j = i - 1; j >= 0; --j) {
49790 if (types[j] !== 'ET') {
49794 types[j] = 'EN';
49797 for (j = i + 1; j < strLength; ++j) {
49798 if (types[j] !== 'ET') {
49802 types[j] = 'EN';
53102 for (var j = 0, jj = fnObj.length; j < jj; j++) {
53106 fn: xref.fetchIfRef(fnObj[j])
53198 var i, j;
53200 for (j = 0; j < cubeVertices; j++) {
53201 cubeN[j] = 1;
53220 for (j = 0; j < cubeVertices; j++) {
53221 if (j & pos) {
53222 cubeN[j] *= n1;
53223 cubeVertex[j] += offset1;
53225 cubeN[j] *= n0;
53226 cubeVertex[j] += offset0;
53234 for (j = 0; j < n; ++j) {
53238 rj += samples[cubeVertex[i] + j] * cubeN[i];
53241 rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]);
53242 dest[destOffset + j] = Math.min(Math.max(rj, range[j][0]), range[j][1]);
53274 for (var j = 0; j < length; ++j) {
53275 dest[destOffset + j] = c0[j] + x * diff[j];
53497 for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
53510 j,
53513 for (i = l, j = r; i < j; i++, j--) {
53515 stack[i] = stack[j];
53516 stack[j] = t;
53519 for (i = l, j = c - 1; i < j; i++, j--) {
53521 stack[i] = stack[j];
53522 stack[j] = t;
53525 for (i = c, j = r; i < j; i++, j--) {
53527 stack[i] = stack[j];
53528 stack[j] = t;
54029 var n, j;
54167 j = num2.number;
54170 if (n <= 0 || !Number.isInteger(n) || !Number.isInteger(j) || stack.length < n) {
54174 j = (j % n + n) % n;
54176 if (j === 0) {
54180 Array.prototype.push.apply(stack, stack.splice(stack.length - n, n - j));
54812 j,
54826 for (j = 0; j < w2; j++) {
54827 oldIndex = py + xScaled[j];
54944 for (var i = 0, j = 0; i < this.decode.length; i += 2, ++j) {
54947 this.decodeCoefficients[j] = isIndexed ? (dmax - dmin) / max : dmax - dmin;
54948 this.decodeAddends[j] = isIndexed ? dmin : max * dmin;
55103 for (var j = 0; j < numComps; j++) {
55104 … buffer[index] = decodeAndClamp(buffer[index], decodeAddends[j], decodeCoefficients[j], max);
55131 for (var j = 0; j < height; j++) {
55186 var alphaBuf, sw, sh, i, ii, j;
55220 for (j = 0; j < numComps; ++j) {
55221 var color = image[imageOffset + j];
55222 var maskOffset = j * 2;
55238 for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) {
55239 rgbaBuf[j] = alphaBuf[i];
55242 for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) {
55243 rgbaBuf[j] = 255;