expected output:
    1a2
    aba
    3a4
490791
def main():
    
    colorama.init()
    print("aaa")
    print("aaa")
    print("aaa")
    print(forward() + up(2) + "b" + up() + back(2) + "1" + forward() + "2" + back(3) + down(2) + "3" + forward() + "4")
92150
private static function iauJd2cal($dj1, $dj2, &$iy, &$im, &$id, &$fd)
    {
        /* Minimum and maximum allowed JD */
        $DJMIN = -68569.5;
        $DJMAX = 1e9;
        $jd;
        $l;
        $n;
        $i;
        $k;
        $dj;
        $d1;
        $d2;
        $f1;
        $f2;
        $f;
        $d;
        /* Verify date is acceptable. */
        $dj = $dj1 + $dj2;
        if ($dj < $DJMIN || $dj > $DJMAX) {
            return -1;
        }
        /* Copy the date, big then small, and re-align to midnight. */
        if ($dj1 >= $dj2) {
            $d1 = $dj1;
            $d2 = $dj2;
        } else {
            $d1 = $dj2;
            $d2 = $dj1;
        }
        $d2 -= 0.5;
        /* Separate day and fraction. */
        $f1 = fmod($d1, 1.0);
        $f2 = fmod($d2, 1.0);
        $f  = fmod($f1 + $f2, 1.0);
        if ($f < 0.0) {
            $f += 1.0;
        }
        $d  = floor($d1 - $f1) + floor($d2 - $f2) + floor($f1 + $f2 - $f);
        $jd = floor($d) + 1;
        /* Express day in Gregorian calendar. */
        // Integer division parts of this block was modified in the PHP translation
        $l = $jd + 68569;
        $n = intval((4 * $l) / 146097);
        $l -= intval((146097 * $n + 3) / 4);
        $i = intval((4000 * ($l + 1)) / 1461001);
        $l -= ((1461 * $i) / 4) - 31;
        $k  = intval((80 * $l) / 2447);
        $id = round($l - (2447 * $k) / 80);
        $l  = intval($k / 11);
        $im = (int)($k + 2 - 12 * $l);
        $iy = (int)(100 * ($n - 49) + $i + $l);
        $fd = $f;

        return 0;
    }
1296443
public static <T extends ImageBase<T>> void abs( T input , T output )
	{
		if( input instanceof ImageGray) {
			if (GrayS8.class == input.getClass()) {
				PixelMath.abs((GrayS8) input, (GrayS8) output);
			} else if (GrayS16.class == input.getClass()) {
				PixelMath.abs((GrayS16) input, (GrayS16) output);
			} else if (GrayS32.class == input.getClass()) {
				PixelMath.abs((GrayS32) input, (GrayS32) output);
			} else if (GrayS64.class == input.getClass()) {
				PixelMath.abs((GrayS64) input, (GrayS64) output);
			} else if (GrayF32.class == input.getClass()) {
				PixelMath.abs((GrayF32) input, (GrayF32) output);
			} else if (GrayF64.class == input.getClass()) {
				PixelMath.abs((GrayF64) input, (GrayF64) output);
			}
			// otherwise assume it is an unsigned image type
		} else if( input instanceof ImageInterleaved ) {
			if (InterleavedS8.class == input.getClass()) {
				PixelMath.abs((InterleavedS8) input, (InterleavedS8) output);
			} else if (InterleavedS16.class == input.getClass()) {
				PixelMath.abs((InterleavedS16) input, (InterleavedS16) output);
			} else if (InterleavedS32.class == input.getClass()) {
				PixelMath.abs((InterleavedS32) input, (InterleavedS32) output);
			} else if (InterleavedS64.class == input.getClass()) {
				PixelMath.abs((InterleavedS64) input, (InterleavedS64) output);
			} else if (InterleavedF32.class == input.getClass()) {
				PixelMath.abs((InterleavedF32) input, (InterleavedF32) output);
			} else if (InterleavedF64.class == input.getClass()) {
				PixelMath.abs((InterleavedF64) input, (InterleavedF64) output);
			}
		} else {
			Planar in = (Planar)input;
			Planar out = (Planar)output;

			for (int i = 0; i < in.getNumBands(); i++) {
				abs(in.getBand(i),out.getBand(i));
			}
		}
	}
857407
def _abs32(ins):
    
    output = _32bit_oper(ins.quad[2])
    output.append('call __ABS32')
    output.append('push de')
    output.append('push hl')
    REQUIRES.add('abs32.asm')
    return output
22034
private int numOfTabs(String line) {
        int i = 0;
        while (i < line.length() && '\t' == line.charAt(i)) {
            i++;
        }
        return i;
    }
29513
def _get_a3(bbar, dbar, slip_moment, mmax):
        
        return ((dbar * (dbar - bbar)) / (bbar ** 2.)) * (slip_moment /
                                                          _scale_moment(mmax))
918183
function step1b$1(token) {
                var r1 = getR1(token);

                if (!r1) {
                    return token;
                }

                if (token.match(/(b|c|d|f|g|h|j|l|m|n|o|p|r|t|v|y|z)s$/)) {
                    return token.slice(0, -1);
                }

                if (token.match(/([^aeiouyæåø]k)s$/)) {
                    return token.slice(0, -1);
                }

                return token;
            }
741318
def _get_a1(bbar, dbar, slip_moment, mmax):
        
        return ((dbar - bbar) / dbar) * (slip_moment / _scale_moment(mmax))
1135095
function () {
        _gpfBinZ = 36969 * (_gpfBinZ & 65535) + (_gpfBinZ >> 16) & _gpfMax32;
        _gpfBinW = 18000 * (_gpfBinW & 65535) + (_gpfBinW >> 16) & _gpfMax32;
        return ((_gpfBinZ << 16) + _gpfBinW & _gpfMax32) + _gpfMax31;
    }
55842
function(a, b)
{
    return Math.abs(a.bb_l + a.bb_r - b.bb_l - b.bb_r) + Math.abs(a.bb_b + a.bb_t - b.bb_b - b.bb_t);
}
311794
void pass_3(int fi, 
	      double in[],  int in0, int istride,
	      double out[], int out0, int ostride,
	      int sign, int product) {
      int k, k1;

      int factor = 3;
      int m = n / factor;
      int q = n / product;
      int product_1 = product / factor;
      int jump = (factor - 1) * product_1;

      double tau = sign * Math.sqrt(3.0) / 2.0;
      int di = istride * m;
      int dj = ostride * product_1;
      int i = in0, j = out0;
      double x_real, x_imag;
      for (k = 0; k < q; k++) {
	double twids[] = twiddle[fi][k];
	double w1_real =       twids[0];
	double w1_imag = -sign*twids[1];
	double w2_real =       twids[2];
	double w2_imag = -sign*twids[3];

	for (k1 = 0; k1 < product_1; k1++) {
	  double z0_real = in[i];
	  double z0_imag = in[i+1];
	  double z1_real = in[i+di];
	  double z1_imag = in[i+di+1];
	  double z2_real = in[i+2*di];
	  double z2_imag = in[i+2*di+1];
	  i += istride;

	  /* compute x = W(3) z */

	  /* t1 = z1 + z2 */
	  double t1_real = z1_real + z2_real;
	  double t1_imag = z1_imag + z2_imag;
	  
	  /* t2 = z0 - t1/2 */
	  double t2_real = z0_real - t1_real / 2.0;
	  double t2_imag = z0_imag - t1_imag / 2.0;
	  
	  /* t3 = (+/-) sin(pi/3)*(z1 - z2) */
	  double t3_real = tau * (z1_real - z2_real);
	  double t3_imag = tau * (z1_imag - z2_imag);
	  
  	  /* apply twiddle factors */

	  /* out0 = 1 * (z0 + t1) */
	  out[j]   = z0_real + t1_real;
	  out[j+1] = z0_imag + t1_imag;
	  
	  /* out1 = w1 * (t2 + i t3) */
	  x_real = t2_real - t3_imag;
	  x_imag = t2_imag + t3_real;
	  out[j+dj]   = w1_real * x_real - w1_imag * x_imag;
	  out[j+dj+1] = w1_real * x_imag + w1_imag * x_real;
	  
	  /* out2 = w2 * (t2 - i t3) */
	  x_real = t2_real + t3_imag;
	  x_imag = t2_imag - t3_real;
	  out[j+2*dj]   = w2_real * x_real - w2_imag * x_imag;
	  out[j+2*dj+1] = w2_real * x_imag + w2_imag * x_real;
  
	  j += ostride;
	}
	j += (factor-1) * dj;
      }}
358526
void putInt(ByteBuffer buf, int adr, int x) {
        buf.elems[adr  ] = (byte)((x >> 24) & 0xFF);
        buf.elems[adr+1] = (byte)((x >> 16) & 0xFF);
        buf.elems[adr+2] = (byte)((x >>  8) & 0xFF);
        buf.elems[adr+3] = (byte)((x      ) & 0xFF);
    }
678287
def isAlphanum(c):
    
    return ((c >= 'a' and c <= 'z') or (c >= '0' and c <= '9') or
            (c >= 'A' and c <= 'Z') or c == '_' or c == '$' or c == '\\' or (c is not None and ord(c) > 126));
109473
def _neg8(ins):
    
    output = _8bit_oper(ins.quad[2])
    output.append('neg')
    output.append('push af')

    return output
474433
def aa3_to_aa1(seq):
    
    if seq is None:
        return None
    return "".join(aa3_to_aa1_lut[aa3]
                   for aa3 in [seq[i:i + 3] for i in range(0, len(seq), 3)])
503758
def expected_bar_value(asset_id, date, colname):
    
    from_asset = asset_id * 100000
    from_colname = OHLCV.index(colname) * 1000
    from_date = (date - PSEUDO_EPOCH).days
    return from_asset + from_colname + from_date
1124512
def BA(self):
        '''
        

        '''
        try:
            return self._BA
        except AttributeError:
            pass
        self._BA = [self.B, self.A]
        return self._BA