thePu239_lamda is lamda in ANS-5.1-1979 Table 8.
2338
def thePu239_lamda
      array = Array.new(23)

      array[0] = 1.002E+01
      array[1] = 6.433E-01
      array[2] = 2.186E-01
      array[3] = 1.004E-01
      array[4] = 3.728E-02
      array[5] = 1.435E-02
      array[6] = 4.549E-03
      array[7] = 1.328E-03
      array[8] = 5.356E-04
      array[9] = 1.730E-04
      array[10] = 4.881E-05
      array[11] = 2.006E-05
      array[12] = 8.319E-06
      array[13] = 2.358E-06
      array[14] = 6.450E-07
      array[15] = 1.278E-07
      array[16] = 2.466E-08
      array[17] = 9.378E-09
      array[18] = 7.450E-10
      array[19] = 2.426E-10
      array[20] = 2.210E-13
      array[21] = 2.640E-14
      array[22] = 1.380E-14

      array
    end
1013040
public final void cmppd(XMMRegister dst, XMMRegister src, Immediate imm8)
  {
    emitX86(INST_CMPPD, dst, src, imm8);
  }
448186
public function OSGB36ToWGS84()
	{
		$airy1830 = new ReferenceEllipsoid;

		$a		= $airy1830->maj;
		$b		= $airy1830->min;
		$eSquared = $airy1830->ecc;
		$phi = deg2rad($this->lat);
		$lambda = deg2rad($this->lng);
		$v = $a / (sqrt(1 - $eSquared * Trig::sinSquared($phi)));
		$H = 0; // height
		$x = ($v + $H) * cos($phi) * cos($lambda);
		$y = ($v + $H) * cos($phi) * sin($lambda);
		$z = ((1 - $eSquared) * $v + $H) * sin($phi);

		$tx =		446.448;
		$ty =		 -124.157;
		$tz =		542.060;
		$s	=		 -0.0000204894;
		$rx = deg2rad(0.00004172222);
		$ry = deg2rad(0.00006861111);
		$rz = deg2rad(0.00023391666);

		$xB = $tx + ($x * (1 + $s)) + (-$rx * $y)	 + ($ry * $z);
		$yB = $ty + ($rz * $x)		+ ($y * (1 + $s)) + (-$rx * $z);
		$zB = $tz + (-$ry * $x)	 + ($rx * $y)		+ ($z * (1 + $s));

		$wgs84 = new ReferenceEllipsoid(ReferenceEllipsoid::WGS84_MAJ, ReferenceEllipsoid::WGS84_MIN);
		$a		= $wgs84->maj;
		$b		= $wgs84->min;
		$eSquared = $wgs84->ecc;

		$lambdaB = rad2deg(atan($yB / $xB));
		$p = sqrt(($xB * $xB) + ($yB * $yB));
		$phiN = atan($zB / ($p * (1 - $eSquared)));

		for ($i = 1; $i < 10; $i++) {
			$v = $a / (sqrt(1 - $eSquared * Trig::sinSquared($phiN)));
			$phiN1 = atan(($zB + ($eSquared * $v * sin($phiN))) / $p);
			$phiN = $phiN1;
		}

		$phiB = rad2deg($phiN);

		$this->lat = $phiB;
		$this->lng = $lambdaB;
	}
127472
static byte[] cppAlignmentAdd8(final byte[] data) {
        XLOGGER.entry();
        final byte[] buffer = new byte[data.length + 8];
        buffer[0] = (byte) 0xc0;
        buffer[1] = (byte) 0xde;
        buffer[2] = (byte) 0xc0;
        buffer[3] = (byte) 0xde;
        buffer[4] = (byte) 0xc0;
        buffer[5] = (byte) 0xde;
        buffer[6] = (byte) 0xc0;
        buffer[7] = (byte) 0xde;
        System.arraycopy(data, 0, buffer, 8, data.length);
        XLOGGER.exit();
        return buffer;
    }
127087
private void clinkstep8(DBIDRef id, DBIDArrayIter it, int n, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableDoubleDataStore m) {
    DBIDVar p_i = DBIDUtil.newVar(), pp_i = DBIDUtil.newVar();
    for(it.seek(0); it.getOffset() < n; it.advance()) {
      p_i.from(pi, it); // p_i = pi[i]
      pp_i.from(pi, p_i); // pp_i = pi[pi[i]]
      if(DBIDUtil.equal(pp_i, id) && lambda.doubleValue(it) >= lambda.doubleValue(p_i)) {
        pi.putDBID(it, id);
      }
    }
  }
439789
private void upgradeDelta(TableEntry10 table, 
                            TableUpgrade upgradeTable,
                            Page10 page,
                            Delta10 delta)
    throws IOException
  {
    try (ReadStream is = openRead(page.segment().address(),
                                  page.segment().length())) {
      is.position(delta.address());
      
      long tail = delta.address() + delta.length();
      
      while (is.position() < tail) {
        upgradeDelta(is, table, upgradeTable, page);
      }
    }
  }
612451
def ean8(self, data, **kwargs):
        """"""
        if not re.match(r'\d{8}', data):
            raise ValueError('JAN-8/EAN-8 symbology requires 8 digits of data; '
                    'got {:d} digits: {!r}'.format(len(data), data))
        barcode.validate_barcode_args(**kwargs)
        return self._ean8_impl(data, **kwargs)
241259
public final void dppd(XMMRegister dst, XMMRegister src, Immediate imm8)
  {
    emitX86(INST_DPPD, dst, src, imm8);
  }
37402
def calc_thermal_fission_functions_with_Np239(t0, ts, read_data)
      read_data.theENp239 * read_data.theR * ((read_data.lamda1 / (read_data.lamda1 - read_data.lamda2)) *
      (1 - Math.exp(-read_data.lamda2 * t0)) * Math.exp(-read_data.lamda2 * ts) -
      (read_data.lamda2 / (read_data.lamda1 - read_data.lamda2)) * (1 - Math.exp(-read_data.lamda1 * t0)) * Math.exp(-read_data.lamda1 * ts))
    end
1239796
private int trMedian5(int ISAd, int v1, int v2, int v3, int v4, int v5) {
        int t;
        if (SA[ISAd + SA[v2]] > SA[ISAd + SA[v3]]) {
            t = v2;
            v2 = v3;
            v3 = t;
        }
        if (SA[ISAd + SA[v4]] > SA[ISAd + SA[v5]]) {
            t = v4;
            v4 = v5;
            v5 = t;
        }
        if (SA[ISAd + SA[v2]] > SA[ISAd + SA[v4]]) {
            t = v2;
            v2 = v4;
            v4 = t;
            t = v3;
            v3 = v5;
            v5 = t;
        }
        if (SA[ISAd + SA[v1]] > SA[ISAd + SA[v3]]) {
            t = v1;
            v1 = v3;
            v3 = t;
        }
        if (SA[ISAd + SA[v1]] > SA[ISAd + SA[v4]]) {
            t = v1;
            v1 = v4;
            v4 = t;
            t = v3;
            v3 = v5;
            v5 = t;
        }
        if (SA[ISAd + SA[v3]] > SA[ISAd + SA[v4]]) {
            return v4;
        }
        return v3;
    }
688392
def _ltu8(ins):
    
    output = _8bit_oper(ins.quad[2], ins.quad[3])
    output.append('cp h')
    output.append('sbc a, a')
    output.append('push af')

    return output
1242798
def QA_indicator_DDI(DataFrame, N=13, N1=26, M=1, M1=5):
    

    H = DataFrame['high']
    L = DataFrame['low']
    DMZ = IF((H + L) > (REF(H, 1) + REF(L, 1)), 
             MAX(ABS(H - REF(H, 1)), ABS(L - REF(L, 1))), 0)
    DMF = IF((H + L) < (REF(H, 1) + REF(L, 1)),
             MAX(ABS(H - REF(H, 1)), ABS(L - REF(L, 1))), 0)
    DIZ = SUM(DMZ, N) / (SUM(DMZ, N) + SUM(DMF, N))
    DIF = SUM(DMF, N) / (SUM(DMF, N) + SUM(DMZ, N))
    ddi = DIZ - DIF
    ADDI = SMA(ddi, N1, M)
    AD = MA(ADDI, M1)
    DICT = {'DDI': ddi, 'ADDI': ADDI, 'AD': AD}

    return pd.DataFrame(DICT)
967454
public final void cmpsd(XMMRegister dst, XMMRegister src, Immediate imm8)
  {
    emitX86(INST_CMPSD, dst, src, imm8);
  }
381446
void radb5(final int ido, final int l1, final float in[], final int in_off, final float out[], final int out_off, final int offset) {
		final float tr11 = 0.309016994374947451262869435595348477f;
		final float ti11 = 0.951056516295153531181938433292089030f;
		final float tr12 = -0.809016994374947340240566973079694435f;
		final float ti12 = 0.587785252292473248125759255344746634f;
		int i, ic;
		float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
		int iw1, iw2, iw3, iw4;
		iw1 = offset;
		iw2 = iw1 + ido;
		iw3 = iw2 + ido;
		iw4 = iw3 + ido;

		int idx0 = l1 * ido;
		for (int k = 0; k < l1; k++) {
			int idx1 = k * ido;
			int idx2 = 5 * idx1;
			int idx3 = idx2 + ido;
			int idx4 = idx3 + ido;
			int idx5 = idx4 + ido;
			int idx6 = idx5 + ido;
			int idx7 = idx1 + idx0;
			int idx8 = idx7 + idx0;
			int idx9 = idx8 + idx0;
			int idx10 = idx9 + idx0;
			int idx11 = in_off + ido - 1;

			float i1r = in[in_off + idx2];

			ti5 = 2 * in[in_off + idx4];
			ti4 = 2 * in[in_off + idx6];
			tr2 = 2 * in[idx11 + idx3];
			tr3 = 2 * in[idx11 + idx5];
			cr2 = i1r + tr11 * tr2 + tr12 * tr3;
			cr3 = i1r + tr12 * tr2 + tr11 * tr3;
			ci5 = ti11 * ti5 + ti12 * ti4;
			ci4 = ti12 * ti5 - ti11 * ti4;

			out[out_off + idx1] = i1r + tr2 + tr3;
			out[out_off + idx7] = cr2 - ci5;
			out[out_off + idx8] = cr3 - ci4;
			out[out_off + idx9] = cr3 + ci4;
			out[out_off + idx10] = cr2 + ci5;
		}
		if (ido == 1)
			return;
		for (int k = 0; k < l1; ++k) {
			int idx1 = k * ido;
			int idx2 = 5 * idx1;
			int idx3 = idx2 + ido;
			int idx4 = idx3 + ido;
			int idx5 = idx4 + ido;
			int idx6 = idx5 + ido;
			int idx7 = idx1 + idx0;
			int idx8 = idx7 + idx0;
			int idx9 = idx8 + idx0;
			int idx10 = idx9 + idx0;
			for (i = 2; i < ido; i += 2) {
				ic = ido - i;
				int widx1 = i - 1 + iw1;
				int widx2 = i - 1 + iw2;
				int widx3 = i - 1 + iw3;
				int widx4 = i - 1 + iw4;
				w1r = wtable_r[widx1 - 1];
				w1i = wtable_r[widx1];
				w2r = wtable_r[widx2 - 1];
				w2i = wtable_r[widx2];
				w3r = wtable_r[widx3 - 1];
				w3i = wtable_r[widx3];
				w4r = wtable_r[widx4 - 1];
				w4i = wtable_r[widx4];

				int idx15 = in_off + i;
				int idx16 = in_off + ic;
				int idx17 = out_off + i;

				int iidx1 = idx15 + idx2;
				int iidx2 = idx16 + idx3;
				int iidx3 = idx15 + idx4;
				int iidx4 = idx16 + idx5;
				int iidx5 = idx15 + idx6;

				float i1i = in[iidx1 - 1];
				float i1r = in[iidx1];
				float i2i = in[iidx2 - 1];
				float i2r = in[iidx2];
				float i3i = in[iidx3 - 1];
				float i3r = in[iidx3];
				float i4i = in[iidx4 - 1];
				float i4r = in[iidx4];
				float i5i = in[iidx5 - 1];
				float i5r = in[iidx5];

				ti5 = i3r + i2r;
				ti2 = i3r - i2r;
				ti4 = i5r + i4r;
				ti3 = i5r - i4r;
				tr5 = i3i - i2i;
				tr2 = i3i + i2i;
				tr4 = i5i - i4i;
				tr3 = i5i + i4i;

				cr2 = i1i + tr11 * tr2 + tr12 * tr3;
				ci2 = i1r + tr11 * ti2 + tr12 * ti3;
				cr3 = i1i + tr12 * tr2 + tr11 * tr3;
				ci3 = i1r + tr12 * ti2 + tr11 * ti3;
				cr5 = ti11 * tr5 + ti12 * tr4;
				ci5 = ti11 * ti5 + ti12 * ti4;
				cr4 = ti12 * tr5 - ti11 * tr4;
				ci4 = ti12 * ti5 - ti11 * ti4;
				dr3 = cr3 - ci4;
				dr4 = cr3 + ci4;
				di3 = ci3 + cr4;
				di4 = ci3 - cr4;
				dr5 = cr2 + ci5;
				dr2 = cr2 - ci5;
				di5 = ci2 - cr5;
				di2 = ci2 + cr5;

				int oidx1 = idx17 + idx1;
				int oidx2 = idx17 + idx7;
				int oidx3 = idx17 + idx8;
				int oidx4 = idx17 + idx9;
				int oidx5 = idx17 + idx10;

				out[oidx1 - 1] = i1i + tr2 + tr3;
				out[oidx1] = i1r + ti2 + ti3;
				out[oidx2 - 1] = w1r * dr2 - w1i * di2;
				out[oidx2] = w1r * di2 + w1i * dr2;
				out[oidx3 - 1] = w2r * dr3 - w2i * di3;
				out[oidx3] = w2r * di3 + w2i * dr3;
				out[oidx4 - 1] = w3r * dr4 - w3i * di4;
				out[oidx4] = w3r * di4 + w3i * dr4;
				out[oidx5 - 1] = w4r * dr5 - w4i * di5;
				out[oidx5] = w4r * di5 + w4i * dr5;
			}
		}
	}
690424
public void orizzonte8( double delta, int quadrata, double beta, double alfa, double[][] Z0, int[][] curv, int[][] shadow,
            double novalue ) {
        /*=====================*/

        int y, I, J;
        double zenith;

        /*======================*/

        for( int j = quadrata; j >= 0; j-- ) {
            I = -1;
            J = -1;
            y = 0;
            for( int jj = j; jj < quadrata; jj++ ) {
                for( int i = (int) floor(1 / tan(beta) * (jj - j)) + 1; i <= (int) floor(1 / tan(beta) * (jj - j + 1))
                        && i <= Z0.length; i++ ) {
                    if (jj > quadrata - Z0[0].length && Z0[i][jj - (quadrata - Z0[0].length)] != novalue) {
                        /*shadow.element[i][jj-(quadrata-Z0.nch)]=j;}}}}*/
                        if (curv[i][jj] == 1 && I == -1) {
                            I = i;
                            J = jj - (quadrata - Z0[0].length);
                            y = 1;
                        } else if (curv[i][jj - (quadrata - Z0[0].length)] == 1 && I != 1) {
                            zenith = (Z0[I][J] - Z0[i][jj - (quadrata - Z0[0].length)])
                                    / sqrt(pow((double) (I - i) * (double) delta, (double) 2)
                                            + pow((double) (J - (jj - (quadrata - Z0[0].length))) * (double) delta, (double) 2));
                            if (zenith <= tan(alfa)) {
                                shadow[i][jj - (quadrata - Z0[0].length)] = 0;
                                I = i;
                                J = jj - (quadrata - Z0[0].length);
                            } else {
                                shadow[i][jj - (quadrata - Z0[0].length)] = 1;
                            }
                        } else if (curv[i][jj - (quadrata - Z0[0].length)] == 0 && y == 1) {
                            zenith = (Z0[I][J] - Z0[i][jj - (quadrata - Z0[0].length)])
                                    / sqrt(pow((double) (I - i) * (double) delta, (double) 2)
                                            + pow((double) (J - (jj - (quadrata - Z0[0].length))) * (double) delta, (double) 2));
                            if (zenith <= tan(alfa)) {
                                shadow[i][jj - (quadrata - Z0[0].length)] = 0;
                                y = 0;
                            } else {
                                shadow[i][jj - (quadrata - Z0[0].length)] = 1;
                            }
                        }
                    }
                }
            }
        }
    }
482500
def systemInformationType5ter():
    """"""
    a = L2PseudoLength(l2pLength=0x12)
    b = TpPd(pd=0x6)
    c = MessageType(mesType=0x6)  # 00000110
    d = NeighbourCellsDescription2()
    packet = a / b / c / d
    return packet
748541
def instruction_LSL_memory(self, opcode, ea, m):
        
        r = self.LSL(m)
#        log.debug("$%x LSL memory value $%x << 1 = $%x and write it to $%x \t| %s" % (
#            self.program_counter,
#            m, r, ea,
#            self.cfg.mem_info.get_shortest(ea)
#        ))
        return ea, r & 0xff