home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / nio / Bits.class (.txt) next >
Encoding:
Java Class File  |  2006-11-29  |  9.9 KB  |  637 lines
  1. package java.nio;
  2.  
  3. import java.security.AccessController;
  4. import sun.misc.Unsafe;
  5. import sun.misc.VM;
  6. import sun.security.action.GetPropertyAction;
  7.  
  8. class Bits {
  9.    private static final Unsafe unsafe = Unsafe.getUnsafe();
  10.    private static ByteOrder byteOrder = null;
  11.    private static int pageSize = -1;
  12.    private static boolean unaligned;
  13.    private static boolean unalignedKnown = false;
  14.    private static volatile long maxMemory = VM.maxDirectMemory();
  15.    private static volatile long reservedMemory = 0L;
  16.    private static boolean memoryLimitSet = false;
  17.    static final int JNI_COPY_TO_ARRAY_THRESHOLD = 6;
  18.    static final int JNI_COPY_FROM_ARRAY_THRESHOLD = 6;
  19.  
  20.    private Bits() {
  21.    }
  22.  
  23.    static short swap(short var0) {
  24.       return (short)(var0 << 8 | var0 >> 8 & 255);
  25.    }
  26.  
  27.    static char swap(char var0) {
  28.       return (char)(var0 << 8 | var0 >> 8 & 255);
  29.    }
  30.  
  31.    static int swap(int var0) {
  32.       return swap((short)var0) << 16 | swap((short)(var0 >> 16)) & '\uffff';
  33.    }
  34.  
  35.    static long swap(long var0) {
  36.       return (long)swap((int)var0) << 32 | (long)swap((int)(var0 >> 32)) & 4294967295L;
  37.    }
  38.  
  39.    private static char makeChar(byte var0, byte var1) {
  40.       return (char)(var0 << 8 | var1 & 255);
  41.    }
  42.  
  43.    static char getCharL(ByteBuffer var0, int var1) {
  44.       return makeChar(var0._get(var1 + 1), var0._get(var1 + 0));
  45.    }
  46.  
  47.    static char getCharL(long var0) {
  48.       return makeChar(_get(var0 + 1L), _get(var0 + 0L));
  49.    }
  50.  
  51.    static char getCharB(ByteBuffer var0, int var1) {
  52.       return makeChar(var0._get(var1 + 0), var0._get(var1 + 1));
  53.    }
  54.  
  55.    static char getCharB(long var0) {
  56.       return makeChar(_get(var0 + 0L), _get(var0 + 1L));
  57.    }
  58.  
  59.    static char getChar(ByteBuffer var0, int var1, boolean var2) {
  60.       return var2 ? getCharB(var0, var1) : getCharL(var0, var1);
  61.    }
  62.  
  63.    static char getChar(long var0, boolean var2) {
  64.       return var2 ? getCharB(var0) : getCharL(var0);
  65.    }
  66.  
  67.    private static byte char1(char var0) {
  68.       return (byte)(var0 >> 8);
  69.    }
  70.  
  71.    private static byte char0(char var0) {
  72.       return (byte)(var0 >> 0);
  73.    }
  74.  
  75.    static void putCharL(ByteBuffer var0, int var1, char var2) {
  76.       var0._put(var1 + 0, char0(var2));
  77.       var0._put(var1 + 1, char1(var2));
  78.    }
  79.  
  80.    static void putCharL(long var0, char var2) {
  81.       _put(var0 + 0L, char0(var2));
  82.       _put(var0 + 1L, char1(var2));
  83.    }
  84.  
  85.    static void putCharB(ByteBuffer var0, int var1, char var2) {
  86.       var0._put(var1 + 0, char1(var2));
  87.       var0._put(var1 + 1, char0(var2));
  88.    }
  89.  
  90.    static void putCharB(long var0, char var2) {
  91.       _put(var0 + 0L, char1(var2));
  92.       _put(var0 + 1L, char0(var2));
  93.    }
  94.  
  95.    static void putChar(ByteBuffer var0, int var1, char var2, boolean var3) {
  96.       if (var3) {
  97.          putCharB(var0, var1, var2);
  98.       } else {
  99.          putCharL(var0, var1, var2);
  100.       }
  101.  
  102.    }
  103.  
  104.    static void putChar(long var0, char var2, boolean var3) {
  105.       if (var3) {
  106.          putCharB(var0, var2);
  107.       } else {
  108.          putCharL(var0, var2);
  109.       }
  110.  
  111.    }
  112.  
  113.    private static short makeShort(byte var0, byte var1) {
  114.       return (short)(var0 << 8 | var1 & 255);
  115.    }
  116.  
  117.    static short getShortL(ByteBuffer var0, int var1) {
  118.       return makeShort(var0._get(var1 + 1), var0._get(var1 + 0));
  119.    }
  120.  
  121.    static short getShortL(long var0) {
  122.       return makeShort(_get(var0 + 1L), _get(var0));
  123.    }
  124.  
  125.    static short getShortB(ByteBuffer var0, int var1) {
  126.       return makeShort(var0._get(var1 + 0), var0._get(var1 + 1));
  127.    }
  128.  
  129.    static short getShortB(long var0) {
  130.       return makeShort(_get(var0), _get(var0 + 1L));
  131.    }
  132.  
  133.    static short getShort(ByteBuffer var0, int var1, boolean var2) {
  134.       return var2 ? getShortB(var0, var1) : getShortL(var0, var1);
  135.    }
  136.  
  137.    static short getShort(long var0, boolean var2) {
  138.       return var2 ? getShortB(var0) : getShortL(var0);
  139.    }
  140.  
  141.    private static byte short1(short var0) {
  142.       return (byte)(var0 >> 8);
  143.    }
  144.  
  145.    private static byte short0(short var0) {
  146.       return (byte)(var0 >> 0);
  147.    }
  148.  
  149.    static void putShortL(ByteBuffer var0, int var1, short var2) {
  150.       var0._put(var1 + 0, short0(var2));
  151.       var0._put(var1 + 1, short1(var2));
  152.    }
  153.  
  154.    static void putShortL(long var0, short var2) {
  155.       _put(var0, short0(var2));
  156.       _put(var0 + 1L, short1(var2));
  157.    }
  158.  
  159.    static void putShortB(ByteBuffer var0, int var1, short var2) {
  160.       var0._put(var1 + 0, short1(var2));
  161.       var0._put(var1 + 1, short0(var2));
  162.    }
  163.  
  164.    static void putShortB(long var0, short var2) {
  165.       _put(var0, short1(var2));
  166.       _put(var0 + 1L, short0(var2));
  167.    }
  168.  
  169.    static void putShort(ByteBuffer var0, int var1, short var2, boolean var3) {
  170.       if (var3) {
  171.          putShortB(var0, var1, var2);
  172.       } else {
  173.          putShortL(var0, var1, var2);
  174.       }
  175.  
  176.    }
  177.  
  178.    static void putShort(long var0, short var2, boolean var3) {
  179.       if (var3) {
  180.          putShortB(var0, var2);
  181.       } else {
  182.          putShortL(var0, var2);
  183.       }
  184.  
  185.    }
  186.  
  187.    private static int makeInt(byte var0, byte var1, byte var2, byte var3) {
  188.       return (var0 & 255) << 24 | (var1 & 255) << 16 | (var2 & 255) << 8 | (var3 & 255) << 0;
  189.    }
  190.  
  191.    static int getIntL(ByteBuffer var0, int var1) {
  192.       return makeInt(var0._get(var1 + 3), var0._get(var1 + 2), var0._get(var1 + 1), var0._get(var1 + 0));
  193.    }
  194.  
  195.    static int getIntL(long var0) {
  196.       return makeInt(_get(var0 + 3L), _get(var0 + 2L), _get(var0 + 1L), _get(var0 + 0L));
  197.    }
  198.  
  199.    static int getIntB(ByteBuffer var0, int var1) {
  200.       return makeInt(var0._get(var1 + 0), var0._get(var1 + 1), var0._get(var1 + 2), var0._get(var1 + 3));
  201.    }
  202.  
  203.    static int getIntB(long var0) {
  204.       return makeInt(_get(var0 + 0L), _get(var0 + 1L), _get(var0 + 2L), _get(var0 + 3L));
  205.    }
  206.  
  207.    static int getInt(ByteBuffer var0, int var1, boolean var2) {
  208.       return var2 ? getIntB(var0, var1) : getIntL(var0, var1);
  209.    }
  210.  
  211.    static int getInt(long var0, boolean var2) {
  212.       return var2 ? getIntB(var0) : getIntL(var0);
  213.    }
  214.  
  215.    private static byte int3(int var0) {
  216.       return (byte)(var0 >> 24);
  217.    }
  218.  
  219.    private static byte int2(int var0) {
  220.       return (byte)(var0 >> 16);
  221.    }
  222.  
  223.    private static byte int1(int var0) {
  224.       return (byte)(var0 >> 8);
  225.    }
  226.  
  227.    private static byte int0(int var0) {
  228.       return (byte)(var0 >> 0);
  229.    }
  230.  
  231.    static void putIntL(ByteBuffer var0, int var1, int var2) {
  232.       var0._put(var1 + 3, int3(var2));
  233.       var0._put(var1 + 2, int2(var2));
  234.       var0._put(var1 + 1, int1(var2));
  235.       var0._put(var1 + 0, int0(var2));
  236.    }
  237.  
  238.    static void putIntL(long var0, int var2) {
  239.       _put(var0 + 3L, int3(var2));
  240.       _put(var0 + 2L, int2(var2));
  241.       _put(var0 + 1L, int1(var2));
  242.       _put(var0 + 0L, int0(var2));
  243.    }
  244.  
  245.    static void putIntB(ByteBuffer var0, int var1, int var2) {
  246.       var0._put(var1 + 0, int3(var2));
  247.       var0._put(var1 + 1, int2(var2));
  248.       var0._put(var1 + 2, int1(var2));
  249.       var0._put(var1 + 3, int0(var2));
  250.    }
  251.  
  252.    static void putIntB(long var0, int var2) {
  253.       _put(var0 + 0L, int3(var2));
  254.       _put(var0 + 1L, int2(var2));
  255.       _put(var0 + 2L, int1(var2));
  256.       _put(var0 + 3L, int0(var2));
  257.    }
  258.  
  259.    static void putInt(ByteBuffer var0, int var1, int var2, boolean var3) {
  260.       if (var3) {
  261.          putIntB(var0, var1, var2);
  262.       } else {
  263.          putIntL(var0, var1, var2);
  264.       }
  265.  
  266.    }
  267.  
  268.    static void putInt(long var0, int var2, boolean var3) {
  269.       if (var3) {
  270.          putIntB(var0, var2);
  271.       } else {
  272.          putIntL(var0, var2);
  273.       }
  274.  
  275.    }
  276.  
  277.    private static long makeLong(byte var0, byte var1, byte var2, byte var3, byte var4, byte var5, byte var6, byte var7) {
  278.       return ((long)var0 & 255L) << 56 | ((long)var1 & 255L) << 48 | ((long)var2 & 255L) << 40 | ((long)var3 & 255L) << 32 | ((long)var4 & 255L) << 24 | ((long)var5 & 255L) << 16 | ((long)var6 & 255L) << 8 | ((long)var7 & 255L) << 0;
  279.    }
  280.  
  281.    static long getLongL(ByteBuffer var0, int var1) {
  282.       return makeLong(var0._get(var1 + 7), var0._get(var1 + 6), var0._get(var1 + 5), var0._get(var1 + 4), var0._get(var1 + 3), var0._get(var1 + 2), var0._get(var1 + 1), var0._get(var1 + 0));
  283.    }
  284.  
  285.    static long getLongL(long var0) {
  286.       return makeLong(_get(var0 + 7L), _get(var0 + 6L), _get(var0 + 5L), _get(var0 + 4L), _get(var0 + 3L), _get(var0 + 2L), _get(var0 + 1L), _get(var0 + 0L));
  287.    }
  288.  
  289.    static long getLongB(ByteBuffer var0, int var1) {
  290.       return makeLong(var0._get(var1 + 0), var0._get(var1 + 1), var0._get(var1 + 2), var0._get(var1 + 3), var0._get(var1 + 4), var0._get(var1 + 5), var0._get(var1 + 6), var0._get(var1 + 7));
  291.    }
  292.  
  293.    static long getLongB(long var0) {
  294.       return makeLong(_get(var0 + 0L), _get(var0 + 1L), _get(var0 + 2L), _get(var0 + 3L), _get(var0 + 4L), _get(var0 + 5L), _get(var0 + 6L), _get(var0 + 7L));
  295.    }
  296.  
  297.    static long getLong(ByteBuffer var0, int var1, boolean var2) {
  298.       return var2 ? getLongB(var0, var1) : getLongL(var0, var1);
  299.    }
  300.  
  301.    static long getLong(long var0, boolean var2) {
  302.       return var2 ? getLongB(var0) : getLongL(var0);
  303.    }
  304.  
  305.    private static byte long7(long var0) {
  306.       return (byte)((int)(var0 >> 56));
  307.    }
  308.  
  309.    private static byte long6(long var0) {
  310.       return (byte)((int)(var0 >> 48));
  311.    }
  312.  
  313.    private static byte long5(long var0) {
  314.       return (byte)((int)(var0 >> 40));
  315.    }
  316.  
  317.    private static byte long4(long var0) {
  318.       return (byte)((int)(var0 >> 32));
  319.    }
  320.  
  321.    private static byte long3(long var0) {
  322.       return (byte)((int)(var0 >> 24));
  323.    }
  324.  
  325.    private static byte long2(long var0) {
  326.       return (byte)((int)(var0 >> 16));
  327.    }
  328.  
  329.    private static byte long1(long var0) {
  330.       return (byte)((int)(var0 >> 8));
  331.    }
  332.  
  333.    private static byte long0(long var0) {
  334.       return (byte)((int)(var0 >> 0));
  335.    }
  336.  
  337.    static void putLongL(ByteBuffer var0, int var1, long var2) {
  338.       var0._put(var1 + 7, long7(var2));
  339.       var0._put(var1 + 6, long6(var2));
  340.       var0._put(var1 + 5, long5(var2));
  341.       var0._put(var1 + 4, long4(var2));
  342.       var0._put(var1 + 3, long3(var2));
  343.       var0._put(var1 + 2, long2(var2));
  344.       var0._put(var1 + 1, long1(var2));
  345.       var0._put(var1 + 0, long0(var2));
  346.    }
  347.  
  348.    static void putLongL(long var0, long var2) {
  349.       _put(var0 + 7L, long7(var2));
  350.       _put(var0 + 6L, long6(var2));
  351.       _put(var0 + 5L, long5(var2));
  352.       _put(var0 + 4L, long4(var2));
  353.       _put(var0 + 3L, long3(var2));
  354.       _put(var0 + 2L, long2(var2));
  355.       _put(var0 + 1L, long1(var2));
  356.       _put(var0 + 0L, long0(var2));
  357.    }
  358.  
  359.    static void putLongB(ByteBuffer var0, int var1, long var2) {
  360.       var0._put(var1 + 0, long7(var2));
  361.       var0._put(var1 + 1, long6(var2));
  362.       var0._put(var1 + 2, long5(var2));
  363.       var0._put(var1 + 3, long4(var2));
  364.       var0._put(var1 + 4, long3(var2));
  365.       var0._put(var1 + 5, long2(var2));
  366.       var0._put(var1 + 6, long1(var2));
  367.       var0._put(var1 + 7, long0(var2));
  368.    }
  369.  
  370.    static void putLongB(long var0, long var2) {
  371.       _put(var0 + 0L, long7(var2));
  372.       _put(var0 + 1L, long6(var2));
  373.       _put(var0 + 2L, long5(var2));
  374.       _put(var0 + 3L, long4(var2));
  375.       _put(var0 + 4L, long3(var2));
  376.       _put(var0 + 5L, long2(var2));
  377.       _put(var0 + 6L, long1(var2));
  378.       _put(var0 + 7L, long0(var2));
  379.    }
  380.  
  381.    static void putLong(ByteBuffer var0, int var1, long var2, boolean var4) {
  382.       if (var4) {
  383.          putLongB(var0, var1, var2);
  384.       } else {
  385.          putLongL(var0, var1, var2);
  386.       }
  387.  
  388.    }
  389.  
  390.    static void putLong(long var0, long var2, boolean var4) {
  391.       if (var4) {
  392.          putLongB(var0, var2);
  393.       } else {
  394.          putLongL(var0, var2);
  395.       }
  396.  
  397.    }
  398.  
  399.    static float getFloatL(ByteBuffer var0, int var1) {
  400.       return Float.intBitsToFloat(getIntL(var0, var1));
  401.    }
  402.  
  403.    static float getFloatL(long var0) {
  404.       return Float.intBitsToFloat(getIntL(var0));
  405.    }
  406.  
  407.    static float getFloatB(ByteBuffer var0, int var1) {
  408.       return Float.intBitsToFloat(getIntB(var0, var1));
  409.    }
  410.  
  411.    static float getFloatB(long var0) {
  412.       return Float.intBitsToFloat(getIntB(var0));
  413.    }
  414.  
  415.    static float getFloat(ByteBuffer var0, int var1, boolean var2) {
  416.       return var2 ? getFloatB(var0, var1) : getFloatL(var0, var1);
  417.    }
  418.  
  419.    static float getFloat(long var0, boolean var2) {
  420.       return var2 ? getFloatB(var0) : getFloatL(var0);
  421.    }
  422.  
  423.    static void putFloatL(ByteBuffer var0, int var1, float var2) {
  424.       putIntL(var0, var1, Float.floatToRawIntBits(var2));
  425.    }
  426.  
  427.    static void putFloatL(long var0, float var2) {
  428.       putIntL(var0, Float.floatToRawIntBits(var2));
  429.    }
  430.  
  431.    static void putFloatB(ByteBuffer var0, int var1, float var2) {
  432.       putIntB(var0, var1, Float.floatToRawIntBits(var2));
  433.    }
  434.  
  435.    static void putFloatB(long var0, float var2) {
  436.       putIntB(var0, Float.floatToRawIntBits(var2));
  437.    }
  438.  
  439.    static void putFloat(ByteBuffer var0, int var1, float var2, boolean var3) {
  440.       if (var3) {
  441.          putFloatB(var0, var1, var2);
  442.       } else {
  443.          putFloatL(var0, var1, var2);
  444.       }
  445.  
  446.    }
  447.  
  448.    static void putFloat(long var0, float var2, boolean var3) {
  449.       if (var3) {
  450.          putFloatB(var0, var2);
  451.       } else {
  452.          putFloatL(var0, var2);
  453.       }
  454.  
  455.    }
  456.  
  457.    static double getDoubleL(ByteBuffer var0, int var1) {
  458.       return Double.longBitsToDouble(getLongL(var0, var1));
  459.    }
  460.  
  461.    static double getDoubleL(long var0) {
  462.       return Double.longBitsToDouble(getLongL(var0));
  463.    }
  464.  
  465.    static double getDoubleB(ByteBuffer var0, int var1) {
  466.       return Double.longBitsToDouble(getLongB(var0, var1));
  467.    }
  468.  
  469.    static double getDoubleB(long var0) {
  470.       return Double.longBitsToDouble(getLongB(var0));
  471.    }
  472.  
  473.    static double getDouble(ByteBuffer var0, int var1, boolean var2) {
  474.       return var2 ? getDoubleB(var0, var1) : getDoubleL(var0, var1);
  475.    }
  476.  
  477.    static double getDouble(long var0, boolean var2) {
  478.       return var2 ? getDoubleB(var0) : getDoubleL(var0);
  479.    }
  480.  
  481.    static void putDoubleL(ByteBuffer var0, int var1, double var2) {
  482.       putLongL(var0, var1, Double.doubleToRawLongBits(var2));
  483.    }
  484.  
  485.    static void putDoubleL(long var0, double var2) {
  486.       putLongL(var0, Double.doubleToRawLongBits(var2));
  487.    }
  488.  
  489.    static void putDoubleB(ByteBuffer var0, int var1, double var2) {
  490.       putLongB(var0, var1, Double.doubleToRawLongBits(var2));
  491.    }
  492.  
  493.    static void putDoubleB(long var0, double var2) {
  494.       putLongB(var0, Double.doubleToRawLongBits(var2));
  495.    }
  496.  
  497.    static void putDouble(ByteBuffer var0, int var1, double var2, boolean var4) {
  498.       if (var4) {
  499.          putDoubleB(var0, var1, var2);
  500.       } else {
  501.          putDoubleL(var0, var1, var2);
  502.       }
  503.  
  504.    }
  505.  
  506.    static void putDouble(long var0, double var2, boolean var4) {
  507.       if (var4) {
  508.          putDoubleB(var0, var2);
  509.       } else {
  510.          putDoubleL(var0, var2);
  511.       }
  512.  
  513.    }
  514.  
  515.    private static byte _get(long var0) {
  516.       return unsafe.getByte(var0);
  517.    }
  518.  
  519.    private static void _put(long var0, byte var2) {
  520.       unsafe.putByte(var0, var2);
  521.    }
  522.  
  523.    static Unsafe unsafe() {
  524.       return unsafe;
  525.    }
  526.  
  527.    static ByteOrder byteOrder() {
  528.       if (byteOrder != null) {
  529.          return byteOrder;
  530.       } else {
  531.          long var0 = unsafe.allocateMemory(8L);
  532.  
  533.          try {
  534.             unsafe.putLong(var0, 72623859790382856L);
  535.             byte var2 = unsafe.getByte(var0);
  536.             switch (var2) {
  537.                case 1:
  538.                   byteOrder = ByteOrder.BIG_ENDIAN;
  539.                   break;
  540.                case 8:
  541.                   byteOrder = ByteOrder.LITTLE_ENDIAN;
  542.                   break;
  543.                default:
  544.                   throw new Error("Unknown byte order");
  545.             }
  546.          } finally {
  547.             unsafe.freeMemory(var0);
  548.          }
  549.  
  550.          return byteOrder;
  551.       }
  552.    }
  553.  
  554.    static int pageSize() {
  555.       if (pageSize == -1) {
  556.          pageSize = unsafe().pageSize();
  557.       }
  558.  
  559.       return pageSize;
  560.    }
  561.  
  562.    static boolean unaligned() {
  563.       if (unalignedKnown) {
  564.          return unaligned;
  565.       } else {
  566.          GetPropertyAction var0 = new GetPropertyAction("os.arch");
  567.          String var1 = (String)AccessController.doPrivileged(var0);
  568.          unaligned = var1.equals("i386") || var1.equals("x86") || var1.equals("amd64");
  569.          unalignedKnown = true;
  570.          return unaligned;
  571.       }
  572.    }
  573.  
  574.    static void reserveMemory(long var0) {
  575.       synchronized(Bits.class) {
  576.          if (!memoryLimitSet && VM.isBooted()) {
  577.             maxMemory = VM.maxDirectMemory();
  578.             memoryLimitSet = true;
  579.          }
  580.  
  581.          if (var0 <= maxMemory - reservedMemory) {
  582.             reservedMemory += var0;
  583.             return;
  584.          }
  585.       }
  586.  
  587.       System.gc();
  588.  
  589.       try {
  590.          Thread.sleep(100L);
  591.       } catch (InterruptedException var6) {
  592.          Thread.currentThread().interrupt();
  593.       }
  594.  
  595.       synchronized(Bits.class) {
  596.          if (reservedMemory + var0 > maxMemory) {
  597.             throw new OutOfMemoryError("Direct buffer memory");
  598.          } else {
  599.             reservedMemory += var0;
  600.          }
  601.       }
  602.    }
  603.  
  604.    static synchronized void unreserveMemory(long var0) {
  605.       if (reservedMemory > 0L) {
  606.          reservedMemory -= var0;
  607.  
  608.          assert reservedMemory > -1L;
  609.       }
  610.  
  611.    }
  612.  
  613.    static native void copyFromByteArray(Object var0, long var1, long var3, long var5);
  614.  
  615.    static native void copyToByteArray(long var0, Object var2, long var3, long var5);
  616.  
  617.    static void copyFromCharArray(Object var0, long var1, long var3, long var5) {
  618.       copyFromShortArray(var0, var1, var3, var5);
  619.    }
  620.  
  621.    static void copyToCharArray(long var0, Object var2, long var3, long var5) {
  622.       copyToShortArray(var0, var2, var3, var5);
  623.    }
  624.  
  625.    static native void copyFromShortArray(Object var0, long var1, long var3, long var5);
  626.  
  627.    static native void copyToShortArray(long var0, Object var2, long var3, long var5);
  628.  
  629.    static native void copyFromIntArray(Object var0, long var1, long var3, long var5);
  630.  
  631.    static native void copyToIntArray(long var0, Object var2, long var3, long var5);
  632.  
  633.    static native void copyFromLongArray(Object var0, long var1, long var3, long var5);
  634.  
  635.    static native void copyToLongArray(long var0, Object var2, long var3, long var5);
  636. }
  637.