Lines Matching refs:bits
31377 BN.prototype.iushln = function iushln(bits) {
31378 assert(typeof bits === 'number' && bits >= 0);
31379 var r = bits % 26;
31380 var s = (bits - r) / 26;
31415 BN.prototype.ishln = function ishln(bits) {
31418 return this.iushln(bits);
31424 BN.prototype.iushrn = function iushrn(bits, hint, extended) {
31425 assert(typeof bits === 'number' && bits >= 0);
31434 var r = bits % 26;
31435 var s = Math.min((bits - r) / 26, this.length);
31482 BN.prototype.ishrn = function ishrn(bits, hint, extended) {
31485 return this.iushrn(bits, hint, extended);
31489 BN.prototype.shln = function shln(bits) {
31490 return this.clone().ishln(bits);
31493 BN.prototype.ushln = function ushln(bits) {
31494 return this.clone().iushln(bits);
31498 BN.prototype.shrn = function shrn(bits) {
31499 return this.clone().ishrn(bits);
31502 BN.prototype.ushrn = function ushrn(bits) {
31503 return this.clone().iushrn(bits);
31520 BN.prototype.imaskn = function imaskn(bits) {
31521 assert(typeof bits === 'number' && bits >= 0);
31522 var r = bits % 26;
31523 var s = (bits - r) / 26;
31545 BN.prototype.maskn = function maskn(bits) {
31546 return this.clone().imaskn(bits);
35065 BN.prototype.iushln = function iushln(bits) {
35066 assert(typeof bits === 'number' && bits >= 0);
35067 var r = bits % 26;
35068 var s = (bits - r) / 26;
35103 BN.prototype.ishln = function ishln(bits) {
35106 return this.iushln(bits);
35112 BN.prototype.iushrn = function iushrn(bits, hint, extended) {
35113 assert(typeof bits === 'number' && bits >= 0);
35122 var r = bits % 26;
35123 var s = Math.min((bits - r) / 26, this.length);
35170 BN.prototype.ishrn = function ishrn(bits, hint, extended) {
35173 return this.iushrn(bits, hint, extended);
35177 BN.prototype.shln = function shln(bits) {
35178 return this.clone().ishln(bits);
35181 BN.prototype.ushln = function ushln(bits) {
35182 return this.clone().iushln(bits);
35186 BN.prototype.shrn = function shrn(bits) {
35187 return this.clone().ishrn(bits);
35190 BN.prototype.ushrn = function ushrn(bits) {
35191 return this.clone().iushrn(bits);
35208 BN.prototype.imaskn = function imaskn(bits) {
35209 assert(typeof bits === 'number' && bits >= 0);
35210 var r = bits % 26;
35211 var s = (bits - r) / 26;
35233 BN.prototype.maskn = function maskn(bits) {
35234 return this.clone().imaskn(bits);
38511 var bits = new BN(obits);
38513 if (shift > 0) bits.ishrn(shift);
38514 return bits;
38517 function bits2octets(bits, q) {
38518 bits = bits2int(bits, q);
38519 bits = bits.mod(q);
38520 var out = Buffer.from(bits.toArray());
45544 function findPrime(bits, gen) {
45545 if (bits < 16) {
45558 num = new BN(randomBytes(Math.ceil(bits / 8)));
45560 while (num.bitLength() > bits) {
46522 for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) {
46523 bits.push(t.andln(1));
46526 for (var i = bits.length - 1; i >= 0; i--) {
46527 if (bits[i] === 0) {
48369 function getNAF(num, w, bits) {
48370 var naf = new Array(Math.max(num.bitLength(), bits) + 1);
65425 var bits;
65479 bits = state.bits;
65488 if (bits < 15) {
65489 hold += input[_in++] << bits;
65490 bits += 8;
65491 hold += input[_in++] << bits;
65492 bits += 8;
65503 bits -= op;
65525 if (bits < op) {
65526 hold += input[_in++] << bits;
65527 bits += 8;
65532 bits -= op;
65536 if (bits < 15) {
65537 hold += input[_in++] << bits;
65538 bits += 8;
65539 hold += input[_in++] << bits;
65540 bits += 8;
65551 bits -= op;
65564 if (bits < op) {
65565 hold += input[_in++] << bits;
65566 bits += 8;
65568 if (bits < op) {
65569 hold += input[_in++] << bits;
65570 bits += 8;
65584 bits -= op; //Tracevv((stderr, "inflate: distance %u\n", dist));
65764 len = bits >> 3;
65766 bits -= len << 3;
65767 hold &= (1 << bits) - 1;
65775 state.bits = bits;
66006 this.bits = 0;
66106 state.bits = 0; //state.lencode = state.distcode = state.next = state.codes;
66242 bits: 9
66253 bits: 5
66347 var bits;
66405 bits = state.bits; //---
66421 while (bits < 16) {
66427 hold += input[next++] << bits;
66428 bits += 8;
66444 bits = 0; //===//
66477 bits -= 4; //---//
66499 bits = 0; //===//
66505 while (bits < 16) {
66511 hold += input[next++] << bits;
66512 bits += 8;
66543 bits = 0; //===//
66551 while (bits < 32) {
66557 hold += input[next++] << bits;
66558 bits += 8;
66577 bits = 0; //===//
66585 while (bits < 16) {
66591 hold += input[next++] << bits;
66592 bits += 8;
66610 bits = 0; //===//
66619 while (bits < 16) {
66625 hold += input[next++] << bits;
66626 bits += 8;
66645 bits = 0; //===//
66780 while (bits < 16) {
66786 hold += input[next++] << bits;
66787 bits += 8;
66799 bits = 0; //===//
66813 while (bits < 32) {
66819 hold += input[next++] << bits;
66820 bits += 8;
66827 bits = 0; //===//
66841 state.bits = bits; //---
66863 hold >>>= bits & 7;
66864 bits -= bits & 7; //---//
66871 while (bits < 3) {
66877 hold += input[next++] << bits;
66878 bits += 8;
66887 bits -= 1; //---//
66909 bits -= 2; //---//
66930 bits -= 2; //---//
66936 hold >>>= bits & 7;
66937 bits -= bits & 7; //---//
66940 while (bits < 32) {
66946 hold += input[next++] << bits;
66947 bits += 8;
66962 bits = 0; //===//
67010 while (bits < 14) {
67016 hold += input[next++] << bits;
67017 bits += 8;
67026 bits -= 5; //---//
67033 bits -= 5; //---//
67040 bits -= 4; //---//
67059 while (bits < 3) {
67065 hold += input[next++] << bits;
67066 bits += 8;
67074 bits -= 3; //---//
67088 bits: state.lenbits
67091 state.lenbits = opts.bits;
67115 if (here_bits <= bits) {
67125 hold += input[next++] << bits;
67126 bits += 8; //---//
67132 bits -= here_bits; //---//
67140 while (bits < n) {
67146 hold += input[next++] << bits;
67147 bits += 8;
67153 bits -= here_bits; //---//
67166 bits -= 2; //---//
67171 while (bits < n) {
67177 hold += input[next++] << bits;
67178 bits += 8;
67184 bits -= here_bits; //---//
67191 bits -= 3; //---//
67196 while (bits < n) {
67202 hold += input[next++] << bits;
67203 bits += 8;
67209 bits -= here_bits; //---//
67216 bits -= 7; //---//
67251 bits: state.lenbits
67256 state.lenbits = opts.bits; // state.lencode = state.next;
67269 bits: state.distbits
67274 state.distbits = opts.bits; // state.distcode = state.next;
67304 state.bits = bits; //---
67315 bits = state.bits; //---
67334 if (here_bits <= bits) {
67344 hold += input[next++] << bits;
67345 bits += 8; //---//
67361 if (last_bits + here_bits <= bits) {
67371 hold += input[next++] << bits;
67372 bits += 8; //---//
67377 bits -= last_bits; //---//
67384 bits -= here_bits; //---//
67420 while (bits < n) {
67426 hold += input[next++] << bits;
67427 bits += 8;
67436 bits -= state.extra; //---//
67456 if (here_bits <= bits) {
67466 hold += input[next++] << bits;
67467 bits += 8; //---//
67483 if (last_bits + here_bits <= bits) {
67493 hold += input[next++] << bits;
67494 bits += 8; //---//
67499 bits -= last_bits; //---//
67506 bits -= here_bits; //---//
67527 while (bits < n) {
67533 hold += input[next++] << bits;
67534 bits += 8;
67543 bits -= state.extra; //---//
67644 while (bits < 32) {
67651 hold |= input[next++] << bits;
67652 bits += 8;
67676 bits = 0; //===//
67687 while (bits < 32) {
67693 hold += input[next++] << bits;
67694 bits += 8;
67706 bits = 0; //===//
67747 state.bits = bits; //---
67768 …strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mod…
67929 var bits = opts.bits; //here = opts.here; /* table entry for duplication */
68029 root = bits;
68051 opts.bits = 1;
68306 opts.bits = root;
68666 var bits;
68678 for (bits = 0; bits <= MAX_BITS; bits++) {
68679 s.bl_count[bits] = 0;
68693 bits = tree[tree[n * 2 + 1]
68699 if (bits > max_length) {
68700 bits = max_length;
68706 = bits;
68715 s.bl_count[bits]++;
68725 s.opt_len += f * (bits + xbits);
68744 bits = max_length - 1;
68746 while (s.bl_count[bits] === 0) {
68747 bits--;
68750 s.bl_count[bits]--;
68753 s.bl_count[bits + 1] += 2;
68770 for (bits = max_length; bits !== 0; bits--) {
68771 n = s.bl_count[bits];
68782 !== bits) {
68784 s.opt_len += (bits - tree[m * 2 + 1]
68791 = bits;
68818 var bits;
68828 for (bits = 1; bits <= MAX_BITS; bits++) {
68829 next_code[bits] = code = code + bl_count[bits - 1] << 1;
68865 var bits;
68938 for (bits = 0; bits <= MAX_BITS; bits++) {
68939 bl_count[bits] = 0;
78192 var bits = this._len * 8; // uint32
78194 if (bits <= 0xffffffff) {
78195 this._block.writeUInt32BE(bits, this._blockSize - 4); // uint64
78198 var lowBits = (bits & 0xffffffff) >>> 0;
78199 var highBits = (bits - lowBits) / 0x100000000;