\n     *       L3psycho_anal.  Compute psycho acoustics.\n     *\n     *       Data returned to the calling program must be delayed by one\n     *       granule.\n     *\n     *       This is done in two places.\n     *       If we do not need to know the blocktype, the copying\n     *       can be done here at the top of the program: we copy the data for\n     *       the last granule (computed during the last call) before it is\n     *       overwritten with the new data.  It looks like this:\n     *\n     *       0. static psymodel_data\n     *       1. calling_program_data = psymodel_data\n     *       2. compute psymodel_data\n     *\n     *       For data which needs to know the blocktype, the copying must be\n     *       done at the end of this loop, and the old values must be saved:\n     *\n     *       0. static psymodel_data_old\n     *       1. compute psymodel_data\n     *       2. compute possible block type of this granule\n     *       3. compute final block type of previous granule based on #2.\n     *       4. calling_program_data = psymodel_data_old\n     *       5. psymodel_data_old = psymodel_data\n     *     psycho_loudness_approx\n     *       jd - 2001 mar 12\n     *    in:  energy   - BLKSIZE/2 elements of frequency magnitudes ^ 2\n     *         gfp      - uses out_samplerate, ATHtype (also needed for ATHformula)\n     *    returns: loudness^2 approximation, a positive value roughly tuned for a value\n     *             of 1.0 for signals near clipping.\n     *    notes:   When calibrated, feeding this function binary white noise at sample\n     *             values +32767 or -32768 should return values that approach 3.\n     *             ATHformula is used to approximate an equal loudness curve.\n     *    future:  Data indicates that the shape of the equal loudness curve varies\n     *             with intensity.  This function might be improved by using an equal\n     *             loudness curve shaped for typical playback levels (instead of the\n     *             ATH, that is shaped for the threshold).  A flexible realization might\n     *             simply bend the existing ATH curve to achieve the desired shape.\n     *             However, the potential gain may not be enough to justify an effort.\n     *

\n     *  For example, with i = 10*log10(m2/m1)/10*16         (= log10(m2/m1)*16)\n     *\n     * abs(i)>8 is equivalent (as i is an integer) to\n     * abs(i)>=9\n     * i>=9 || i<=-9\n     * equivalent to (as i is the biggest integer smaller than log10(m2/m1)*16\n     * or the smallest integer bigger than log10(m2/m1)*16 depending on the sign of log10(m2/m1)*16)\n     * log10(m2/m1)>=9/16 || log10(m2/m1)<=-9/16\n     * exp10 is strictly increasing thus this is equivalent to\n     * m2/m1 >= 10^(9/16) || m2/m1<=10^(-9/16) which are comparisons to constants\n     *

\n */\n\n /**\n * as in if(i>8)\n */\n var I1LIMIT = 8;\n /**\n * as in if(i>24) . changed 23\n */\n var I2LIMIT = 23;\n /**\n * as in if(m<15)\n */\n var MLIMIT = 15;\n\n var ma_max_i1;\n var ma_max_i2;\n var ma_max_m;\n\n /**\n * This is the masking table:
\n * According to tonality, values are going from 0dB (TMN) to 9.3dB (NMT).
\n * After additive masking computation, 8dB are added, so final values are\n * going from 8dB to 17.3dB\n *\n * pow(10, -0.0..-0.6)\n */\n var tab = [1.0, 0.79433, 0.63096, 0.63096,\n 0.63096, 0.63096, 0.63096, 0.25119, 0.11749];\n\n function init_mask_add_max_values() {\n ma_max_i1 = Math.pow(10, (I1LIMIT + 1) / 16.0);\n ma_max_i2 = Math.pow(10, (I2LIMIT + 1) / 16.0);\n ma_max_m = Math.pow(10, (MLIMIT) / 10.0);\n }\n\n var table1 = [3.3246 * 3.3246,\n 3.23837 * 3.23837, 3.15437 * 3.15437, 3.00412 * 3.00412,\n 2.86103 * 2.86103, 2.65407 * 2.65407, 2.46209 * 2.46209,\n 2.284 * 2.284, 2.11879 * 2.11879, 1.96552 * 1.96552,\n 1.82335 * 1.82335, 1.69146 * 1.69146, 1.56911 * 1.56911,\n 1.46658 * 1.46658, 1.37074 * 1.37074, 1.31036 * 1.31036,\n 1.25264 * 1.25264, 1.20648 * 1.20648, 1.16203 * 1.16203,\n 1.12765 * 1.12765, 1.09428 * 1.09428, 1.0659 * 1.0659,\n 1.03826 * 1.03826, 1.01895 * 1.01895, 1];\n\n var table2 = [1.33352 * 1.33352,\n 1.35879 * 1.35879, 1.38454 * 1.38454, 1.39497 * 1.39497,\n 1.40548 * 1.40548, 1.3537 * 1.3537, 1.30382 * 1.30382,\n 1.22321 * 1.22321, 1.14758 * 1.14758, 1];\n\n var table3 = [2.35364 * 2.35364,\n 2.29259 * 2.29259, 2.23313 * 2.23313, 2.12675 * 2.12675,\n 2.02545 * 2.02545, 1.87894 * 1.87894, 1.74303 * 1.74303,\n 1.61695 * 1.61695, 1.49999 * 1.49999, 1.39148 * 1.39148,\n 1.29083 * 1.29083, 1.19746 * 1.19746, 1.11084 * 1.11084,\n 1.03826 * 1.03826];\n\n /**\n * addition of simultaneous masking Naoki Shibata 2000/7\n */\n function mask_add(m1, m2, kk, b, gfc, shortblock) {\n var ratio;\n\n if (m2 > m1) {\n if (m2 < (m1 * ma_max_i2))\n ratio = m2 / m1;\n else\n return (m1 + m2);\n } else {\n if (m1 >= (m2 * ma_max_i2))\n return (m1 + m2);\n ratio = m1 / m2;\n }\n\n /* Should always be true, just checking */\n assert(m1 >= 0);\n assert(m2 >= 0);\n\n m1 += m2;\n //if (((long)(b + 3) & 0xffffffff) <= 3 + 3) {\n if ((b + 3) <= 3 + 3) {\n /* approximately, 1 bark = 3 partitions */\n /* 65% of the cases */\n /* originally \'if(i > 8)\' */\n if (ratio >= ma_max_i1) {\n /* 43% of the total */\n return m1;\n }\n\n /* 22% of the total */\n var i = 0 | (Util.FAST_LOG10_X(ratio, 16.0));\n return m1 * table2[i];\n }\n\n /**\n *

\n         * m<15 equ log10((m1+m2)/gfc.ATH.cb[k])<1.5\n         * equ (m1+m2)/gfc.ATH.cb[k]<10^1.5\n         * equ (m1+m2)<10^1.5 * gfc.ATH.cb[k]\n         *

\n                     * dont use long block pre-echo control if previous granule was\n                     * a short block.  This is to avoid the situation:\n                     * frame0:  quiet (very low masking)\n                     * frame1:  surge  (triggers short blocks)\n                     * frame2:  regular frame.  looks like pre-echo when compared to\n                     *          frame0, but all pre-echo was in frame1.\n                     *

\n             * dont use long block pre-echo control if previous granule was\n             * a short block.  This is to avoid the situation:\n             * frame0:  quiet (very low masking)\n             * frame1:  surge  (triggers short blocks)\n             * frame2:  regular frame.  looks like pre-echo when compared to\n             *          frame0, but all pre-echo was in frame1.\n             *

\n */\n /*\n * chn=0,1 L and R channels chn=2,3 S and M channels.\n */\n if (gfc.blocktype_old[chn & 0x01] == Encoder.SHORT_TYPE) {\n var ecb_limit = rpelev * gfc.nb_1[chn][b];\n if (ecb_limit > 0) {\n thr[b] = Math.min(ecb, ecb_limit);\n } else {\n /**\n *

\n                     * Robert 071209:\n                     * Because we don\'t calculate long block psy when we know a granule\n                     * should be of short blocks, we don\'t have any clue how the granule\n                     * before would have looked like as a long block. So we have to guess\n                     * a little bit for this END_TYPE block.\n                     * Most of the time we get away with this sloppyness. (fingers crossed :)\n                     * The speed increase is worth it.\n                     *

\n         * Normalization.  The spreading function should be normalized so that:\n         * +inf\n         * /\n         * |  s3 [ bark ]  d(bark)   =  1\n         * /\n         * -inf\n         *

\n */\n tempx /= .6609193;\n return tempx;\n }\n\n /**\n * see for example "Zwicker: Psychoakustik, 1982; ISBN 3-540-11401-7\n */\n function freq2bark(freq) {\n /* input: freq in hz output: barks */\n if (freq < 0)\n freq = 0;\n freq = freq * 0.001;\n return 13.0 * Math.atan(.76 * freq) + 3.5\n * Math.atan(freq * freq / (7.5 * 7.5));\n }\n\n function init_numline(numlines, bo, bm, bval, bval_width, mld, bo_w, sfreq, blksize, scalepos, deltafreq, sbmax) {\n var b_frq = new_float(Encoder.CBANDS + 1);\n var sample_freq_frac = sfreq / (sbmax > 15 ? 2 * 576 : 2 * 192);\n var partition = new_int(Encoder.HBLKSIZE);\n var i;\n sfreq /= blksize;\n var j = 0;\n var ni = 0;\n /* compute numlines, the number of spectral lines in each partition band */\n /* each partition band should be about DELBARK wide. */\n for (i = 0; i < Encoder.CBANDS; i++) {\n var bark1;\n var j2;\n bark1 = freq2bark(sfreq * j);\n\n b_frq[i] = sfreq * j;\n\n for (j2 = j; freq2bark(sfreq * j2) - bark1 < DELBARK\n && j2 <= blksize / 2; j2++)\n ;\n\n numlines[i] = j2 - j;\n ni = i + 1;\n\n while (j < j2) {\n assert(j < Encoder.HBLKSIZE);\n partition[j++] = i;\n }\n if (j > blksize / 2) {\n j = blksize / 2;\n ++i;\n break;\n }\n }\n assert(i < Encoder.CBANDS);\n b_frq[i] = sfreq * j;\n\n for (var sfb = 0; sfb < sbmax; sfb++) {\n var i1, i2, start, end;\n var arg;\n start = scalepos[sfb];\n end = scalepos[sfb + 1];\n\n i1 = 0 | Math.floor(.5 + deltafreq * (start - .5));\n if (i1 < 0)\n i1 = 0;\n i2 = 0 | Math.floor(.5 + deltafreq * (end - .5));\n\n if (i2 > blksize / 2)\n i2 = blksize / 2;\n\n bm[sfb] = (partition[i1] + partition[i2]) / 2;\n bo[sfb] = partition[i2];\n var f_tmp = sample_freq_frac * end;\n /*\n * calculate how much of this band belongs to current scalefactor\n * band\n */\n bo_w[sfb] = (f_tmp - b_frq[bo[sfb]])\n / (b_frq[bo[sfb] + 1] - b_frq[bo[sfb]]);\n if (bo_w[sfb] < 0) {\n bo_w[sfb] = 0;\n } else {\n if (bo_w[sfb] > 1) {\n bo_w[sfb] = 1;\n }\n }\n /* setup stereo demasking thresholds */\n /* formula reverse enginerred from plot in paper */\n arg = freq2bark(sfreq * scalepos[sfb] * deltafreq);\n arg = ( Math.min(arg, 15.5) / 15.5);\n\n mld[sfb] = Math.pow(10.0,\n 1.25 * (1 - Math.cos(Math.PI * arg)) - 2.5);\n }\n\n /* compute bark values of each critical band */\n j = 0;\n for (var k = 0; k < ni; k++) {\n var w = numlines[k];\n var bark1, bark2;\n\n bark1 = freq2bark(sfreq * (j));\n bark2 = freq2bark(sfreq * (j + w - 1));\n bval[k] = .5 * (bark1 + bark2);\n\n bark1 = freq2bark(sfreq * (j - .5));\n bark2 = freq2bark(sfreq * (j + w - .5));\n bval_width[k] = bark2 - bark1;\n j += w;\n }\n\n return ni;\n }\n\n function init_s3_values(s3ind, npart, bval, bval_width, norm, use_old_s3) {\n var s3 = new_float_n([Encoder.CBANDS, Encoder.CBANDS]);\n /*\n * The s3 array is not linear in the bark scale.\n *\n * bval[x] should be used to get the bark value.\n */\n var j;\n var numberOfNoneZero = 0;\n\n /**\n *

\n         * s[i][j], the value of the spreading function,\n         * centered at band j (masker), for band i (maskee)\n         *\n         * i.e.: sum over j to spread into signal barkval=i\n         * NOTE: i and j are used opposite as in the ISO docs\n         *

\n         *  from Painter & Spanias\n         *           modified by Gabriel Bouvigne to better fit the reality\n         *           ath =    3.640 * pow(f,-0.8)\n         *           - 6.800 * exp(-0.6*pow(f-3.4,2.0))\n         *           + 6.000 * exp(-0.15*pow(f-8.7,2.0))\n         *           + 0.6* 0.001 * pow(f,4.0);\n         *\n         *\n         *           In the past LAME was using the Painter &Spanias formula.\n         *           But we had some recurrent problems with HF content.\n         *           We measured real ATH values, and found the older formula\n         *           to be inaccurate in the higher part. So we made this new\n         *           formula and this solved most of HF problematic test cases.\n         *           The tradeoff is that in VBR mode it increases a lot the\n         *           bitrate.\n         *

frames total number of audio frames in the bitstream\n *
bytes total number of bytes in the bitstream\n *
toc table of contents\n *

\n *\n * toc (table of contents) gives seek points for random access.
\n * The ith entry determines the seek point for i-percent duration.
\n * seek point in bytes = (toc[i]/256.0) * total_bitstream_bytes
\n * e.g. half duration seek point = (toc[50]/256.0) * total_bitstream_bytes\n */\nVBRTag.NUMTOCENTRIES = 100;\nVBRTag.MAXFRAMESIZE = 2880;\n\nfunction VBRTag() {\n\n var lame;\n var bs;\n var v;\n\n this.setModules = function (_lame, _bs, _v) {\n lame = _lame;\n bs = _bs;\n v = _v;\n };\n\n var FRAMES_FLAG = 0x0001;\n var BYTES_FLAG = 0x0002;\n var TOC_FLAG = 0x0004;\n var VBR_SCALE_FLAG = 0x0008;\n\n var NUMTOCENTRIES = VBRTag.NUMTOCENTRIES;\n\n /**\n * (0xB40) the max freeformat 640 32kHz framesize.\n */\n var MAXFRAMESIZE = VBRTag.MAXFRAMESIZE;\n\n /**\n *

\n     *    4 bytes for Header Tag\n     *    4 bytes for Header Flags\n     *  100 bytes for entry (toc)\n     *    4 bytes for frame size\n     *    4 bytes for stream size\n     *    4 bytes for VBR scale. a VBR quality indicator: 0=best 100=worst\n     *   20 bytes for LAME tag.  for example, "LAME3.12 (beta 6)"\n     * ___________\n     *  140 bytes\n     *

\n */\n var VBRHEADERSIZE = (NUMTOCENTRIES + 4 + 4 + 4 + 4 + 4);\n\n var LAMEHEADERSIZE = (VBRHEADERSIZE + 9 + 1 + 1 + 8\n + 1 + 1 + 3 + 1 + 1 + 2 + 4 + 2 + 2);\n\n /**\n * The size of the Xing header MPEG-1, bit rate in kbps.\n */\n var XING_BITRATE1 = 128;\n /**\n * The size of the Xing header MPEG-2, bit rate in kbps.\n */\n var XING_BITRATE2 = 64;\n /**\n * The size of the Xing header MPEG-2.5, bit rate in kbps.\n */\n var XING_BITRATE25 = 32;\n\n /**\n * ISO-8859-1 charset for byte to string operations.\n */\n var ISO_8859_1 = null; //Charset.forName("ISO-8859-1");\n\n /**\n * VBR header magic string.\n */\n var VBRTag0 = "Xing";\n /**\n * VBR header magic string (VBR == VBRMode.vbr_off).\n */\n var VBRTag1 = "Info";\n\n /**\n * Lookup table for fast CRC-16 computation. Uses the polynomial\n * x^16+x^15+x^2+1\n */\n var crc16Lookup = [0x0000, 0xC0C1, 0xC181, 0x0140,\n 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741,\n 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41,\n 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40,\n 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941,\n 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40,\n 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540,\n 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341,\n 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141,\n 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740,\n 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40,\n 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41,\n 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940,\n 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41,\n 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541,\n 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340,\n 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141,\n 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740,\n 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40,\n 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41,\n 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940,\n 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41,\n 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541,\n 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340,\n 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140,\n 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741,\n 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41,\n 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40,\n 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941,\n 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40,\n 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540,\n 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341,\n 0x4100, 0x81C1, 0x8081, 0x4040];\n\n /***********************************************************************\n * Robert Hegemann 2001-01-17\n ***********************************************************************/\n\n function addVbr(v, bitrate) {\n v.nVbrNumFrames++;\n v.sum += bitrate;\n v.seen++;\n\n if (v.seen < v.want) {\n return;\n }\n\n if (v.pos < v.size) {\n v.bag[v.pos] = v.sum;\n v.pos++;\n v.seen = 0;\n }\n if (v.pos == v.size) {\n for (var i = 1; i < v.size; i += 2) {\n v.bag[i / 2] = v.bag[i];\n }\n v.want *= 2;\n v.pos /= 2;\n }\n }\n\n function xingSeekTable(v, t) {\n if (v.pos <= 0)\n return;\n\n for (var i = 1; i < NUMTOCENTRIES; ++i) {\n var j = i / NUMTOCENTRIES, act, sum;\n var indx = 0 | (Math.floor(j * v.pos));\n if (indx > v.pos - 1)\n indx = v.pos - 1;\n act = v.bag[indx];\n sum = v.sum;\n var seek_point = 0 | (256. * act / sum);\n if (seek_point > 255)\n seek_point = 255;\n t[i] = 0xff & seek_point;\n }\n }\n\n /**\n * Add VBR entry, used to fill the VBR TOC entries.\n *\n * @param gfp\n * global flags\n */\n this.addVbrFrame = function (gfp) {\n var gfc = gfp.internal_flags;\n var kbps = Tables.bitrate_table[gfp.version][gfc.bitrate_index];\n assert(gfc.VBR_seek_table.bag != null);\n addVbr(gfc.VBR_seek_table, kbps);\n }\n\n /**\n * Read big endian integer (4-bytes) from header.\n *\n * @param buf\n * header containing the integer\n * @param bufPos\n * offset into the header\n * @return extracted integer\n */\n function extractInteger(buf, bufPos) {\n var x = buf[bufPos + 0] & 0xff;\n x <<= 8;\n x |= buf[bufPos + 1] & 0xff;\n x <<= 8;\n x |= buf[bufPos + 2] & 0xff;\n x <<= 8;\n x |= buf[bufPos + 3] & 0xff;\n return x;\n }\n\n /**\n * Write big endian integer (4-bytes) in the header.\n *\n * @param buf\n * header to write the integer into\n * @param bufPos\n * offset into the header\n * @param value\n * integer value to write\n */\n function createInteger(buf, bufPos, value) {\n buf[bufPos + 0] = 0xff & ((value >> 24) & 0xff);\n buf[bufPos + 1] = 0xff & ((value >> 16) & 0xff);\n buf[bufPos + 2] = 0xff & ((value >> 8) & 0xff);\n buf[bufPos + 3] = 0xff & (value & 0xff);\n }\n\n /**\n * Write big endian short (2-bytes) in the header.\n *\n * @param buf\n * header to write the integer into\n * @param bufPos\n * offset into the header\n * @param value\n * integer value to write\n */\n function createShort(buf, bufPos, value) {\n buf[bufPos + 0] = 0xff & ((value >> 8) & 0xff);\n buf[bufPos + 1] = 0xff & (value & 0xff);\n }\n\n /**\n * Check for magic strings (Xing/Info).\n *\n * @param buf\n * header to check\n * @param bufPos\n * header offset to check\n * @return magic string found\n */\n function isVbrTag(buf, bufPos) {\n return new String(buf, bufPos, VBRTag0.length(), ISO_8859_1)\n .equals(VBRTag0)\n || new String(buf, bufPos, VBRTag1.length(), ISO_8859_1)\n .equals(VBRTag1);\n }\n\n function shiftInBitsValue(x, n, v) {\n return 0xff & ((x << n) | (v & ~(-1 << n)));\n }\n\n /**\n * Construct the MP3 header using the settings of the global flags.\n *\n *

\n         * Xing VBR pretends to be a 48kbs layer III frame.  (at 44.1kHz).\n         * (at 48kHz they use 56kbs since 48kbs frame not big enough for\n         * table of contents)\n         * let\'s always embed Xing header inside a 64kbs layer III frame.\n         * this gives us enough room for a LAME version string too.\n         * size determined by sampling frequency (MPEG1)\n         * 32kHz:    216 bytes@48kbs    288bytes@ 64kbs\n         * 44.1kHz:  156 bytes          208bytes@64kbs     (+1 if padding = 1)\n         * 48kHz:    144 bytes          192\n         *\n         * MPEG 2 values are the same since the framesize and samplerate\n         * are each reduced by a factor of 2.\n         *