diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptLiterals.java b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptLiterals.java
index 0e4a148..f848152 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptLiterals.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptLiterals.java
@@ -15,6 +15,7 @@
  */
 package com.google.gwt.dev.jjs.impl;
 
+import com.google.gwt.dev.jjs.SourceInfo;
 import com.google.gwt.dev.jjs.ast.Context;
 import com.google.gwt.dev.jjs.ast.JBooleanLiteral;
 import com.google.gwt.dev.jjs.ast.JCharLiteral;
@@ -25,8 +26,11 @@
 import com.google.gwt.dev.jjs.ast.JNullLiteral;
 import com.google.gwt.dev.jjs.ast.JStringLiteral;
 import com.google.gwt.dev.jjs.ast.JVisitor;
-import com.google.gwt.dev.js.ast.JsArrayLiteral;
+import com.google.gwt.dev.js.ast.JsExpression;
+import com.google.gwt.dev.js.ast.JsNameRef;
+import com.google.gwt.dev.js.ast.JsObjectLiteral;
 import com.google.gwt.dev.js.ast.JsProgram;
+import com.google.gwt.dev.js.ast.JsPropertyInitializer;
 import com.google.gwt.dev.js.ast.JsVisitable;
 import com.google.gwt.lang.LongLib;
 
@@ -40,10 +44,6 @@
  */
 public class GenerateJavaScriptLiterals extends JVisitor {
 
-  static {
-    LongLib.RUN_IN_JVM = true;
-  }
-
   private final JsProgram program;
   private final Stack<JsVisitable<?>> nodeStack = new Stack<JsVisitable<?>>();
 
@@ -78,13 +78,20 @@
 
   @Override
   public void endVisit(JLongLiteral x, Context ctx) {
-    JsArrayLiteral arrayLit = new JsArrayLiteral(x.getSourceInfo());
-    double[] doubleArray = LongLib.typeChange(x.getValue());
-    arrayLit.getExpressions().add(
-        program.getNumberLiteral(x.getSourceInfo(), doubleArray[0]));
-    arrayLit.getExpressions().add(
-        program.getNumberLiteral(x.getSourceInfo(), doubleArray[1]));
-    push(arrayLit);
+    SourceInfo sourceInfo = x.getSourceInfo();
+    int[] intArray = LongLib.getAsIntArray(x.getValue());
+    JsObjectLiteral objectLit = new JsObjectLiteral(sourceInfo);
+    List<JsPropertyInitializer> inits = objectLit.getPropertyInitializers();
+    JsExpression label0 = new JsNameRef(sourceInfo, "l");
+    JsExpression label1 = new JsNameRef(sourceInfo, "m");
+    JsExpression label2 = new JsNameRef(sourceInfo, "h");
+    JsExpression value0 = program.getNumberLiteral(sourceInfo, intArray[0]);
+    JsExpression value1 = program.getNumberLiteral(sourceInfo, intArray[1]);
+    JsExpression value2 = program.getNumberLiteral(sourceInfo, intArray[2]);
+    inits.add(new JsPropertyInitializer(sourceInfo, label0, value0));
+    inits.add(new JsPropertyInitializer(sourceInfo, label1, value1));
+    inits.add(new JsPropertyInitializer(sourceInfo, label2, value2));
+    push(objectLit);
   }
 
   @Override
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/SameParameterValueOptimizer.java b/dev/core/src/com/google/gwt/dev/jjs/impl/SameParameterValueOptimizer.java
index 59a624f..1d30097 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/SameParameterValueOptimizer.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/SameParameterValueOptimizer.java
@@ -44,6 +44,8 @@
  * Detects when same literal is passed as parameter value, and uses literal
  * instead of parameter. The unused parameter will be removed by other analyses.
  */
+// TODO: this optimization can mistakenly act on methods such as LongLib.fromInt
+// since only one call is seen in LongLib itself.
 public class SameParameterValueOptimizer {
   /**
    * Fill parameterValues map.
diff --git a/dev/core/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Array.java b/dev/core/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Array.java
index 4e907dc..02ddedd 100644
--- a/dev/core/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Array.java
+++ b/dev/core/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Array.java
@@ -209,7 +209,8 @@
   /**
    * Creates a primitive JSON array of a given seedType.
    * 
-   * @param seedType the primitive type of the array; 0: null; 1: zero; 2: false
+   * @param seedType the primitive type of the array; 0: null; 1: zero;
+   *     2: false; 3: (long) 0
    * @param length the requested length
    * @see #NULL_SEED_TYPE
    * @see #ZERO_SEED_TYPE
@@ -218,8 +219,15 @@
    */
   private static native Array createFromSeed(int seedType, int length) /*-{
     var array = new Array(length);
-    if (seedType > 0) {
-      var value = [null, 0, false, [0, 0]][seedType];
+    if (seedType == 3) {
+      // Fill array with the type used by LongLib
+      for (var i = 0; i < length; ++i) {
+        var value = new Object();
+        value.l = value.m = value.h = 0;
+        array[i] = value;
+      }
+    } else if (seedType > 0) {
+      var value = [null, 0, false][seedType];
       for (var i = 0; i < length; ++i) {
         array[i] = value;
       }
diff --git a/dev/core/super/com/google/gwt/lang/LongLib.java b/dev/core/super/com/google/gwt/lang/LongLib.java
index 9226113..1afcfa8 100644
--- a/dev/core/super/com/google/gwt/lang/LongLib.java
+++ b/dev/core/super/com/google/gwt/lang/LongLib.java
@@ -15,687 +15,439 @@
  */
 package com.google.gwt.lang;
 
-import static com.google.gwt.lang.LongLib.Const.LN_2;
-import static com.google.gwt.lang.LongLib.Const.MAX_VALUE;
-import static com.google.gwt.lang.LongLib.Const.MIN_VALUE;
-import static com.google.gwt.lang.LongLib.Const.NEG_ONE;
-import static com.google.gwt.lang.LongLib.Const.ONE;
-import static com.google.gwt.lang.LongLib.Const.TWO;
-import static com.google.gwt.lang.LongLib.Const.TWO_PWR_24;
-import static com.google.gwt.lang.LongLib.Const.ZERO;
-
-import com.google.gwt.core.client.UnsafeNativeLong;
-
 /**
  * Implements a Java <code>long</code> in a way that can be translated to
  * JavaScript.
  */
-public class LongLib {
-  /*
-   * Implementation: An array of two doubles, low and high, such that high+low
-   * is mathematically equivalent to the original integer. Since a JavaScript
-   * Number does not hold enough bits to precisely calculate high+low, all
-   * operations must be implemented carefully. "low" is always between 0 and
-   * 2^32-1 inclusive. "high" is always between -2^63 and 2^63-2^32 inclusive
-   * and is a multiple of 2^32. The sign of the number is determined entirely by
-   * "high". Since low is always positive, small negative numbers are encoded
-   * with high=-2^32. For example, -1 is encoded as { high=-2^32, low=2^32-1 }.
-   * 
-   * Note that this class must be careful using type "long". Being the
-   * implementation of the long type for web mode, any place it uses a long is
-   * not usable in web mode. There are currently two such methods:
-   * {@link #toLong(double[])} and {@link #make(long)}.
-   * 
-   * The GWT RPC serialization code is dependent on the internal format of the
-   * long type; any changes made to this class should be reflected in the
-   * implementations of SerializationStreamReader and Writer.
-   */
-
-  /**
-   * Use nested class to avoid clinit on outer.
-   */
-  static class CachedInts {
-    // Between -128 and 127.
-    static double[][] boxedValues = new double[256][];
-  }
+public class LongLib extends LongLibBase {
 
   static class Const {
-    static final double LN_2 = Math.log(2);
-    static final double[] MAX_VALUE = typeChange(Long.MAX_VALUE);
-    static final double[] MIN_VALUE = typeChange(Long.MIN_VALUE);
-    static final double[] NEG_ONE = fromInt(-1);
-    static final double[] ONE = fromInt(1);
-    static final double[] TWO = fromInt(2);
+    static final LongEmul MAX_VALUE = create(MASK, MASK, MASK_2 >> 1);
+    static final LongEmul MIN_VALUE = create(0, 0, SIGN_BIT_VALUE);
+    static final LongEmul ONE = fromInt(1);
+    static final LongEmul TWO = fromInt(2);
+    static final LongEmul ZERO = fromInt(0);
+  }
+  
+  private static LongEmul[] boxedValues;
+  
+  public static LongEmul add(LongEmul a, LongEmul b) {
+    int sum0 = getL(a) + getL(b);
+    int sum1 = getM(a) + getM(b) + (sum0 >> BITS);
+    int sum2 = getH(a) + getH(b) + (sum1 >> BITS);
 
-    /**
-     * Half of the number of bits we expect to be precise.
-     * 
-     * @see LongLib#PRECISION_BITS
-     */
-    static final double[] TWO_PWR_24 = typeChange(0x1000000L);
+    return create(sum0 & MASK, sum1 & MASK, sum2 & MASK_2);
+  }
 
-    static final double[] ZERO = fromInt(0);
+  public static LongEmul and(LongEmul a, LongEmul b) {
+    return create(getL(a) & getL(b), getM(a) & getM(b), getH(a) & getH(b));
   }
 
   /**
-   * Set this to false before calling any methods when using this class outside
-   * of GWT!
-   */
-  public static boolean RUN_IN_JVM = false;
-
-  /**
-   * Number of bits we expect to be accurate for a double representing a large
-   * integer.
-   */
-  private static final int PRECISION_BITS = 48;
-
-  /**
-   * Index of the high bits in a 2-double array.
-   */
-  private static final int HIGH = 1;
-  private static final double HIGH_MAX = 9223372032559808512d;
-  private static final double HIGH_MIN = -9223372036854775808d;
-
-  /**
-   * Index of the low bits in a 2-double array.
-   */
-  private static final int LOW = 0;
-  private static final double LOW_MAX = 4294967295d;
-  private static final double LOW_MIN = 0;
-
-  private static final double TWO_PWR_15_DBL = 0x8000;
-  private static final double TWO_PWR_16_DBL = 0x10000;
-  private static final double TWO_PWR_31_DBL = TWO_PWR_16_DBL * TWO_PWR_15_DBL;
-  private static final double TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
-  private static final double TWO_PWR_48_DBL = TWO_PWR_32_DBL * TWO_PWR_16_DBL;
-  private static final double TWO_PWR_63_DBL = TWO_PWR_32_DBL * TWO_PWR_31_DBL;
-  private static final double TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
-
-  public static double[] add(double[] a, double[] b) {
-    double newHigh = a[HIGH] + b[HIGH];
-    double newLow = a[LOW] + b[LOW];
-    return create(newLow, newHigh);
-  }
-
-  public static double[] and(double[] a, double[] b) {
-    return makeFromBits(highBits(a) & highBits(b), lowBits(a) & lowBits(b));
-  }
-
-  /**
-   * Compare the receiver to the argument.
+   * Compare the receiver a to the argument b.
    * 
-   * @return 0 if they are the same, 1 if the receiver is greater, -1 if the
-   *         argument is greater.
+   * @return 0 if they are the same, a positive value if the receiver is
+   * greater, or a negative value if the argument is greater.
    */
-  public static int compare(double[] a, double[] b) {
-    if (eq(a, b)) {
-      return 0;
+  public static int compare(LongEmul a, LongEmul b) {
+    int signA = sign(a);
+    int signB = sign(b);
+    if (signA != signB) {
+      return signB - signA;
     }
 
-    boolean nega = isNegative(a);
-    boolean negb = isNegative(b);
-    if (nega && !negb) {
-      return -1;
-    }
-    if (!nega && negb) {
-      return 1;
+    int a2 = getH(a);
+    int b2 = getH(b);
+    if (a2 != b2) {
+      return a2 - b2;
     }
 
-    // at this point, the signs are the same, so subtraction will not overflow
-    assert (nega == negb);
-    if (isNegative(sub(a, b))) {
-      return -1;
-    } else {
-      return 1;
+    int a1 = getM(a);
+    int b1 = getM(b);
+    if (a1 != b1) {
+      return a1 - b1;
     }
+
+    int a0 = getL(a);
+    int b0 = getL(b);
+    return a0 - b0;
   }
 
-  public static double[] div(double[] a, double[] b) {
-    if (isZero(b)) {
-      throw new ArithmeticException("/ by zero");
+  public static LongEmul div(LongEmul a, LongEmul b) {
+    return divMod(a, b, false);
+  }
+  
+  public static boolean eq(LongEmul a, LongEmul b) {
+    return getL(a) == getL(b) && getM(a) == getM(b) && getH(a) == getH(b);
+  }
+
+  public static LongEmul fromDouble(double value) {
+    if (Double.isNaN(value)) {
+      return Const.ZERO;
     }
-    if (isZero(a)) {
-      return ZERO;
+    if (value < -TWO_PWR_63_DBL) {
+      return Const.MIN_VALUE;
+    }
+    if (value >= TWO_PWR_63_DBL) {
+      return Const.MAX_VALUE;
     }
 
-    if (eq(a, MIN_VALUE)) {
-      // handle a==MIN_VALUE carefully because of overflow issues
-      if (eq(b, ONE) || eq(b, NEG_ONE)) {
-        // this strange exception is described in JLS3 17.17.2
-        return MIN_VALUE;
-      }
-      // at this point, abs(b) >= 2, so |a/b| < -MIN_VALUE
-      double[] halfa = shr(a, 1);
-      double[] approx = shl(div(halfa, b), 1);
-      double[] rem = sub(a, mul(b, approx));
-      assert gt(rem, MIN_VALUE);
-      return add(approx, div(rem, b));
+    boolean negative = false;
+    if (value < 0) {
+      negative = true;
+      value = -value;
     }
-
-    if (eq(b, MIN_VALUE)) {
-      assert !eq(a, MIN_VALUE);
-      return ZERO;
+    int a2 = 0;
+    if (value >= TWO_PWR_44_DBL) {
+      a2 = (int) (value / TWO_PWR_44_DBL);
+      value -= a2 * TWO_PWR_44_DBL;
     }
-
-    // To keep the implementation compact, make a and be
-    // both be positive and swap the sign of the result
-    // if necessary.
-    if (isNegative(a)) {
-      if (isNegative(b)) {
-        return div(neg(a), neg(b));
-      } else {
-        return neg(div(neg(a), b));
-      }
+    int a1 = 0;
+    if (value >= TWO_PWR_22_DBL) {
+      a1 = (int) (value / TWO_PWR_22_DBL);
+      value -= a1 * TWO_PWR_22_DBL;
     }
-    assert (!isNegative(a));
-    if (isNegative(b)) {
-      return neg(div(a, neg(b)));
+    int a0 = (int) value;
+    LongEmul result = create(a0, a1, a2);
+    if (negative) {
+      negate(result);
     }
-    assert (!isNegative(b));
-
-    // Use float division to approximate the answer.
-    // Repeat until the remainder is less than b.
-    double[] result = ZERO;
-    double[] rem = a;
-    while (gte(rem, b)) {
-      // approximate using float division
-      double[] deltaResult = fromDouble(Math.floor(toDoubleRoundDown(rem)
-          / toDoubleRoundUp(b)));
-      if (isZero(deltaResult)) {
-        deltaResult = Const.ONE;
-      }
-      double[] deltaRem = mul(deltaResult, b);
-
-      assert gte(deltaResult, ONE);
-      assert lte(deltaRem, rem);
-      result = add(result, deltaResult);
-      rem = sub(rem, deltaRem);
-    }
-
     return result;
   }
 
-  public static boolean eq(double[] a, double[] b) {
-    return ((a[LOW] == b[LOW]) && (a[HIGH] == b[HIGH]));
-  }
-
-  public static double[] fromDouble(double value) {
-    if (Double.isNaN(value)) {
-      return ZERO;
-    }
-    if (value < -TWO_PWR_63_DBL) {
-      return MIN_VALUE;
-    }
-    if (value >= TWO_PWR_63_DBL) {
-      return MAX_VALUE;
-    }
-    if (value > 0) {
-      return create(Math.floor(value), 0.0);
-    } else {
-      return create(Math.ceil(value), 0.0);
-    }
-  }
-
-  public static double[] fromInt(int value) {
+  public static LongEmul fromInt(int value) {
     if (value > -129 && value < 128) {
       int rebase = value + 128;
-      double[] result = CachedInts.boxedValues[rebase];
+      if (boxedValues == null) {
+        boxedValues = new LongEmul[256];
+      }
+      LongEmul result = boxedValues[rebase];
       if (result == null) {
-        result = CachedInts.boxedValues[rebase] = internalFromInt(value);
+        result = boxedValues[rebase] = create(value);
       }
       return result;
     }
-    return internalFromInt(value);
+
+    return create(value);
   }
-
-  public static boolean gt(double[] a, double[] b) {
-    return compare(a, b) > 0;
+  
+  /**
+   * Return a triple of ints { low, middle, high } that concatenate bitwise to
+   * the given number.
+   */
+  public static int[] getAsIntArray(long l) {
+    int[] a = new int[3];
+    a[0] = (int) (l & MASK);
+    a[1] = (int) ((l >> BITS) & MASK);
+    a[2] = (int) ((l >> BITS01) & MASK_2);
+    return a;
   }
-
-  public static boolean gte(double[] a, double[] b) {
-    return compare(a, b) >= 0;
-  }
-
-  public static boolean lt(double[] a, double[] b) {
-    return compare(a, b) < 0;
-  }
-
-  public static boolean lte(double[] a, double[] b) {
-    return compare(a, b) <= 0;
-  }
-
-  public static double[] mod(double[] a, double[] b) {
-    return sub(a, mul(div(a, b), b));
-  }
-
-  public static double[] mul(double[] a, double[] b) {
-    if (isZero(a)) {
-      return ZERO;
-    }
-    if (isZero(b)) {
-      return ZERO;
-    }
-
-    // handle MIN_VALUE carefully, because neg(MIN_VALUE)==MIN_VALUE
-    if (eq(a, MIN_VALUE)) {
-      return multByMinValue(b);
-    }
-    if (eq(b, MIN_VALUE)) {
-      return multByMinValue(a);
-    }
-
-    // If either argument is negative, change it to positive, multiply,
-    // and then negate the result.
-    if (isNegative(a)) {
-      if (isNegative(b)) {
-        return mul(neg(a), neg(b));
+  
+  public static boolean gt(LongEmul a, LongEmul b) {
+    int signa = getH(a) >> (BITS2 - 1);
+    int signb = getH(b) >> (BITS2 - 1);
+    if (signa == 0) {
+      if (signb != 0 || getH(a) > getH(b)
+          || (getH(a) == getH(b) && getM(a) > getM(b))
+          || (getH(a) == getH(b) && getM(a) == getM(b) && getL(a) > getL(b))) {
+        return true;
       } else {
-        return neg(mul(neg(a), b));
+        return false;
+      }
+    } else {
+      if (signb == 0 || getH(a) < getH(b)
+          || (getH(a) == getH(b) && getM(a) < getM(b))
+          || (getH(a) == getH(b) && getM(a) == getM(b) && getL(a) <= getL(b))) {
+        return false;
+      } else {
+        return true;
       }
     }
-    assert (!isNegative(a));
-    if (isNegative(b)) {
-      return neg(mul(a, neg(b)));
-    }
-    assert (!isNegative(b));
-
-    // If both numbers are small, use float multiplication
-    if (lt(a, TWO_PWR_24) && lt(b, TWO_PWR_24)) {
-      return create(toDouble(a) * toDouble(b), 0.0);
-    }
-
-    // Divide each number into 4 chunks of 16 bits, and then add
-    // up 4x4 multiplies. Skip the six multiplies where the result
-    // mod 2^64 would be 0.
-    double a3 = a[HIGH] % TWO_PWR_48_DBL;
-    double a4 = a[HIGH] - a3;
-    double a1 = a[LOW] % TWO_PWR_16_DBL;
-    double a2 = a[LOW] - a1;
-
-    double b3 = b[HIGH] % TWO_PWR_48_DBL;
-    double b4 = b[HIGH] - b3;
-    double b1 = b[LOW] % TWO_PWR_16_DBL;
-    double b2 = b[LOW] - b1;
-
-    double[] res = ZERO;
-
-    res = addTimes(res, a4, b1);
-    res = addTimes(res, a3, b2);
-    res = addTimes(res, a3, b1);
-    res = addTimes(res, a2, b3);
-    res = addTimes(res, a2, b2);
-    res = addTimes(res, a2, b1);
-    res = addTimes(res, a1, b4);
-    res = addTimes(res, a1, b3);
-    res = addTimes(res, a1, b2);
-    res = addTimes(res, a1, b1);
-
-    return res;
   }
 
-  public static double[] neg(double[] a) {
-    if (eq(a, MIN_VALUE)) {
-      return MIN_VALUE;
-    }
-    double newHigh = -a[HIGH];
-    double newLow = -a[LOW];
-    if (newLow > LOW_MAX) {
-      newLow -= TWO_PWR_32_DBL;
-      newHigh += TWO_PWR_32_DBL;
-    }
-    if (newLow < LOW_MIN) {
-      newLow += TWO_PWR_32_DBL;
-      newHigh -= TWO_PWR_32_DBL;
-    }
-    return createNormalized(newLow, newHigh);
-  }
-
-  public static boolean neq(double[] a, double[] b) {
-    return ((a[LOW] != b[LOW]) || (a[HIGH] != b[HIGH]));
-  }
-
-  public static double[] not(double[] a) {
-    return makeFromBits(~highBits(a), ~lowBits(a));
-  }
-
-  public static double[] or(double[] a, double[] b) {
-    return makeFromBits(highBits(a) | highBits(b), lowBits(a) | lowBits(b));
-  }
-
-  public static double[] shl(double[] a, int n) {
-    n &= 63;
-
-    if (eq(a, MIN_VALUE)) {
-      if (n == 0) {
-        return a;
+  public static boolean gte(LongEmul a, LongEmul b) {
+    int signa = getH(a) >> (BITS2 - 1);
+    int signb = getH(b) >> (BITS2 - 1);
+    if (signa == 0) {
+      if (signb != 0 || getH(a) > getH(b)
+          || (getH(a) == getH(b) && getM(a) > getM(b))
+          || (getH(a) == getH(b) && getM(a) == getM(b) && getL(a) >= getL(b))) {
+        return true;
       } else {
-        return ZERO;
+        return false;
+      }
+    } else {
+      if (signb == 0 || getH(a) < getH(b)
+          || (getH(a) == getH(b) && getM(a) < getM(b))
+          || (getH(a) == getH(b) && getM(a) == getM(b) && getL(a) < getL(b))) {
+        return false;
+      } else {
+        return true;
       }
     }
-
-    if (isNegative(a)) {
-      return neg(shl(neg(a), n));
-    }
-
-    final double twoToN = pwrAsDouble(n);
-
-    double newHigh = a[HIGH] * twoToN % TWO_PWR_64_DBL;
-    double newLow = a[LOW] * twoToN;
-    double diff = newLow - (newLow % TWO_PWR_32_DBL);
-    newHigh += diff;
-    newLow -= diff;
-    if (newHigh >= TWO_PWR_63_DBL) {
-      newHigh -= TWO_PWR_64_DBL;
-    }
-
-    return createNormalized(newLow, newHigh);
   }
 
-  public static double[] shr(double[] a, int n) {
+  public static boolean lt(LongEmul a, LongEmul b) {
+    return !gte(a, b);
+  }
+
+  public static boolean lte(LongEmul a, LongEmul b) {
+    return !gt(a, b);
+  }
+
+  public static LongEmul mod(LongEmul a, LongEmul b) {
+    divMod(a, b, true);
+    return remainder;
+  }
+
+  // Assumes BITS == 22
+  public static LongEmul mul(LongEmul a, LongEmul b) {
+    // Grab 13-bit chunks
+    int a0 = getL(a) & 0x1fff;
+    int a1 = (getL(a) >> 13) | ((getM(a) & 0xf) << 9);
+    int a2 = (getM(a) >> 4) & 0x1fff;
+    int a3 = (getM(a) >> 17) | ((getH(a) & 0xff) << 5);
+    int a4 = (getH(a) & 0xfff00) >> 8;
+
+    int b0 = getL(b) & 0x1fff;
+    int b1 = (getL(b) >> 13) | ((getM(b) & 0xf) << 9);
+    int b2 = (getM(b) >> 4) & 0x1fff;
+    int b3 = (getM(b) >> 17) | ((getH(b) & 0xff) << 5);
+    int b4 = (getH(b) & 0xfff00) >> 8;
+
+    // Compute partial products
+    // Optimization: if b is small, avoid multiplying by parts that are 0
+    int p0 = a0 * b0; // << 0
+    int p1 = a1 * b0; // << 13
+    int p2 = a2 * b0; // << 26
+    int p3 = a3 * b0; // << 39
+    int p4 = a4 * b0; // << 52
+    
+    if (b1 != 0) {
+      p1 += a0 * b1;
+      p2 += a1 * b1;
+      p3 += a2 * b1;
+      p4 += a3 * b1;
+    }
+    if (b2 != 0) {
+      p2 += a0 * b2;
+      p3 += a1 * b2;
+      p4 += a2 * b2;
+    }
+    if (b3 != 0) {
+      p3 += a0 * b3;
+      p4 += a1 * b3;
+    }
+    if (b4 != 0) {
+      p4 += a0 * b4;
+    }
+
+    // Accumulate into 22-bit chunks:
+    // .........................................c10|...................c00|
+    // |....................|..................xxxx|xxxxxxxxxxxxxxxxxxxxxx| p0
+    // |....................|......................|......................|
+    // |....................|...................c11|......c01.............|
+    // |....................|....xxxxxxxxxxxxxxxxxx|xxxxxxxxx.............| p1
+    // |....................|......................|......................|
+    // |.................c22|...............c12....|......................|
+    // |..........xxxxxxxxxx|xxxxxxxxxxxxxxxxxx....|......................| p2
+    // |....................|......................|......................|
+    // |.................c23|..c13.................|......................|
+    // |xxxxxxxxxxxxxxxxxxxx|xxxxx.................|......................| p3
+    // |....................|......................|......................|
+    // |.........c24........|......................|......................|
+    // |xxxxxxxxxxxx........|......................|......................| p4
+
+    int c00 = p0 & 0x3fffff;
+    int c01 = (p1 & 0x1ff) << 13;
+    int c0 = c00 + c01;
+
+    int c10 = p0 >> 22;
+    int c11 = p1 >> 9;
+    int c12 = (p2 & 0x3ffff) << 4;
+    int c13 = (p3 & 0x1f) << 17;
+    int c1 = c10 + c11 + c12 + c13;
+
+    int c22 = p2 >> 18;
+    int c23 = p3 >> 5;
+    int c24 = (p4 & 0xfff) << 8;
+    int c2 = c22 + c23 + c24;
+
+    // Propagate high bits from c0 -> c1, c1 -> c2
+    c1 += c0 >> BITS;
+    c0 &= MASK;
+    c2 += c1 >> BITS;
+    c1 &= MASK;
+    c2 &= MASK_2;
+
+    return create(c0, c1, c2);
+  }
+
+  public static LongEmul neg(LongEmul a) {
+    int neg0 = (~getL(a) + 1) & MASK;
+    int neg1 = (~getM(a) + (neg0 == 0 ? 1 : 0)) & MASK;
+    int neg2 = (~getH(a) + ((neg0 == 0 && neg1 == 0) ? 1 : 0)) & MASK_2;
+
+    return create(neg0, neg1, neg2);
+  }
+
+  public static boolean neq(LongEmul a, LongEmul b) {
+    return getL(a) != getL(b) || getM(a) != getM(b) || getH(a) != getH(b);
+  }
+
+  public static LongEmul not(LongEmul a) {
+    return create((~getL(a)) & MASK, (~getM(a)) & MASK, (~getH(a)) & MASK_2);
+  }
+
+  public static LongEmul or(LongEmul a, LongEmul b) {
+    return create(getL(a) | getL(b), getM(a) | getM(b), getH(a) | getH(b));
+  }
+
+  public static LongEmul shl(LongEmul a, int n) {
     n &= 63;
-    double shiftFact = pwrAsDouble(n);
-    double newHigh = Math.floor(a[HIGH] / shiftFact);
-    double newLow = Math.floor(a[LOW] / shiftFact);
 
-    /*
-     * Doing the above floors separately on each component is safe. If n<32,
-     * a[HIGH]/shiftFact is guaranteed to be an integer already. For n>32,
-     * a[HIGH]/shiftFact will have fractional bits, but we need to discard them
-     * as they shift away. We will end up discarding all of a[LOW] in this case,
-     * as it divides out to entirely fractional.
-     */
+    int res0, res1, res2;
+    if (n < BITS) {
+      res0 = getL(a) << n;
+      res1 = (getM(a) << n) | (getL(a) >> (BITS - n));
+      res2 = (getH(a) << n) | (getM(a) >> (BITS - n));
+    } else if (n < BITS01) {
+      res0 = 0;
+      res1 = getL(a) << (n - BITS);
+      res2 = (getM(a) << (n - BITS)) | (getL(a) >> (BITS01 - n));
+    } else {
+      res0 = 0;
+      res1 = 0;
+      res2 = getL(a) << (n - BITS01);
+    }
 
-    return create(newLow, newHigh);
+    return create(res0 & MASK, res1 & MASK, res2 & MASK_2);
+  }
+
+  public static LongEmul shr(LongEmul a, int n) {
+    n &= 63;
+
+    int res0, res1, res2;
+
+    // Sign extend h(a)
+    int a2 = getH(a);
+    boolean negative = (a2 & SIGN_BIT_VALUE) != 0;
+    if (negative) {
+      a2 |= ~MASK_2;
+    }
+
+    if (n < BITS) {
+      res2 = a2 >> n;
+      res1 = (getM(a) >> n) | (a2 << (BITS - n));
+      res0 = (getL(a) >> n) | (getM(a) << (BITS - n));
+    } else if (n < BITS01) {
+      res2 = negative ? MASK_2 : 0;
+      res1 = a2 >> (n - BITS);
+      res0 = (getM(a) >> (n - BITS)) | (a2 << (BITS01 - n));
+    } else {
+      res2 = negative ? MASK_2 : 0;
+      res1 = negative ? MASK : 0;
+      res0 = a2 >> (n - BITS01);
+    }
+
+    return create(res0 & MASK, res1 & MASK, res2 & MASK_2);
   }
 
   /**
    * Logical right shift. It does not preserve the sign of the input.
    */
-  public static double[] shru(double[] a, int n) {
+  public static LongEmul shru(LongEmul a, int n) {
     n &= 63;
-    double[] sr = shr(a, n);
-    if (isNegative(a)) {
-      // the following changes the high bits to 0, using
-      // a formula from JLS3 section 15.19
-      sr = add(sr, shl(TWO, 63 - n));
+
+    int res0, res1, res2;
+    int a2 = getH(a) & MASK_2;
+    if (n < BITS) {
+      res2 = a2 >>> n;
+      res1 = (getM(a) >> n) | (a2 << (BITS - n));
+      res0 = (getL(a) >> n) | (getM(a) << (BITS - n));
+    } else if (n < BITS01) {
+      res2 = 0;
+      res1 = a2 >>> (n - BITS);
+      res0 = (getM(a) >> (n - BITS)) | (getH(a) << (BITS01 - n));
+    } else {
+      res2 = 0;
+      res1 = 0;
+      res0 = a2 >>> (n - BITS01);
     }
 
-    return sr;
+    return create(res0 & MASK, res1 & MASK, res2 & MASK_2);
   }
 
-  public static double[] sub(double[] a, double[] b) {
-    double newHigh = a[HIGH] - b[HIGH];
-    double newLow = a[LOW] - b[LOW];
-    return create(newLow, newHigh);
+  public static LongEmul sub(LongEmul a, LongEmul b) {
+    int sum0 = getL(a) - getL(b);
+    int sum1 = getM(a) - getM(b) + (sum0 >> BITS);
+    int sum2 = getH(a) - getH(b) + (sum1 >> BITS);
+
+    return create(sum0 & MASK, sum1 & MASK, sum2 & MASK_2);
   }
 
-  /**
-   * Cast from long to double or float.
-   */
-  public static double toDouble(double[] a) {
-    return a[HIGH] + a[LOW];
+  public static double toDouble(LongEmul a) {
+    if (LongLib.eq(a, Const.MIN_VALUE)) {
+      return -9223372036854775808.0;
+    }
+    if (LongLib.lt(a, Const.ZERO)) {
+      return -toDoubleHelper(LongLib.neg(a));
+    }
+    return toDoubleHelper(a);
   }
-
-  /**
-   * Cast from long to int.
-   */
-  public static int toInt(double[] a) {
-    return lowBits(a);
+  
+  // Assumes Integer.MIN_VALUE <= a <= Integer.MAX_VALUE
+  public static int toInt(LongEmul a) {
+    return getL(a) | (getM(a) << BITS);
   }
-
-  /**
-   * Implicit conversion from long to String.
-   */
-  public static String toString(double[] a) {
-    if (isZero(a)) {
+  
+  public static String toString(LongEmul a) {
+    if (LongLibBase.isZero(a)) {
       return "0";
     }
-
-    if (eq(a, MIN_VALUE)) {
-      // Special-case MIN_VALUE because neg(MIN_VALUE)==MIN_VALUE
+  
+    if (LongLibBase.isMinValue(a)) {
+      // Special-case MIN_VALUE because neg(MIN_VALUE) == MIN_VALUE
       return "-9223372036854775808";
     }
-
-    if (isNegative(a)) {
+  
+    if (LongLibBase.isNegative(a)) {
       return "-" + toString(neg(a));
     }
-
-    double[] rem = a;
+  
+    LongEmul rem = a;
     String res = "";
-
-    while (!isZero(rem)) {
+  
+    while (!LongLibBase.isZero(rem)) {
       // Do several digits each time through the loop, so as to
       // minimize the calls to the very expensive emulated div.
       final int tenPowerZeroes = 9;
       final int tenPower = 1000000000;
-      double[] tenPowerLong = fromInt(tenPower);
-
-      final double[] remDivTenPower = div(rem, tenPowerLong);
-      String digits = "" + toInt(sub(rem, mul(remDivTenPower, tenPowerLong)));
-      rem = remDivTenPower;
-
-      if (!isZero(rem)) {
+      LongEmul tenPowerLong = fromInt(tenPower);
+  
+      rem = LongLibBase.divMod(rem, tenPowerLong, true);
+      String digits = "" + toInt(LongLibBase.remainder);
+  
+      if (!LongLibBase.isZero(rem)) {
         int zeroesNeeded = tenPowerZeroes - digits.length();
         for (; zeroesNeeded > 0; zeroesNeeded--) {
           digits = "0" + digits;
         }
       }
-
+  
       res = digits + res;
     }
-
+  
     return res;
   }
-
-  public static double[] typeChange(long value) {
-    if (RUN_IN_JVM) {
-      return makeFromBits((int) (value >> 32), (int) value);
-    } else {
-      return typeChange0(value);
-    }
+  
+  public static LongEmul xor(LongEmul a, LongEmul b) {
+    return create(getL(a) ^ getL(b), getM(a) ^ getM(b), getH(a) ^ getH(b));
   }
-
-  public static double[] xor(double[] a, double[] b) {
-    return makeFromBits(highBits(a) ^ highBits(b), lowBits(a) ^ lowBits(b));
-  }
-
-  static long toLong(double[] a) {
-    return (long) a[HIGH] + (long) a[LOW];
-  }
-
-  private static double[] addTimes(double[] accum, double a, double b) {
-    if (a == 0.0) {
-      return accum;
-    }
-    if (b == 0.0) {
-      return accum;
-    }
-    return add(accum, create(a * b, 0.0));
-  }
-
-  /*
-   * Make a new instance equal to valueLow+valueHigh. The arguments do not need
-   * to be normalized, though by convention valueHigh and valueLow will hold the
-   * high and low bits, respectively.
-   */
-  private static double[] create(double valueLow, double valueHigh) {
-    assert (!Double.isNaN(valueHigh));
-    assert (!Double.isNaN(valueLow));
-    assert (!Double.isInfinite(valueHigh));
-    assert (!Double.isInfinite(valueLow));
-    assert (Math.floor(valueHigh) == valueHigh);
-    assert (Math.floor(valueLow) == valueLow);
-
-    // remove overly high bits
-    valueHigh %= TWO_PWR_64_DBL;
-    valueLow %= TWO_PWR_64_DBL;
-
-    // segregate high and low bits between high and low
-    {
-      double diffHigh = valueHigh % TWO_PWR_32_DBL;
-      double diffLow = Math.floor(valueLow / TWO_PWR_32_DBL) * TWO_PWR_32_DBL;
-
-      valueHigh = (valueHigh - diffHigh) + diffLow;
-      valueLow = (valueLow - diffLow) + diffHigh;
-    }
-
-    // Most or all of the while's in this implementation could probably be if's,
-    // but they are left as while's for now pending a careful review.
-
-    // make valueLow be positive
-    while (valueLow < LOW_MIN) {
-      valueLow += TWO_PWR_32_DBL;
-      valueHigh -= TWO_PWR_32_DBL;
-    }
-
-    // make valueLow not too large
-    while (valueLow > LOW_MAX) {
-      valueLow -= TWO_PWR_32_DBL;
-      valueHigh += TWO_PWR_32_DBL;
-    }
-
-    // make valueHigh within range
-    valueHigh = valueHigh % TWO_PWR_64_DBL;
-    while (valueHigh > HIGH_MAX) {
-      valueHigh -= TWO_PWR_64_DBL;
-    }
-    while (valueHigh < HIGH_MIN) {
-      valueHigh += TWO_PWR_64_DBL;
-    }
-
-    return createNormalized(valueLow, valueHigh);
-  }
-
-  /**
-   * Create an instance. The high and low parts must be normalized. Normal
-   * callers should use the factory method {@link #make(double, double) make}.
-   */
-  private static double[] createNormalized(double valueLow, double valueHigh) {
-    assert (valueHigh <= HIGH_MAX);
-    assert (valueHigh >= HIGH_MIN);
-    assert (valueLow >= 0);
-    assert (valueLow <= LOW_MAX);
-    assert (valueHigh % TWO_PWR_32_DBL == 0);
-    assert (Math.floor(valueLow) == valueLow); // no fractional bits allowed
-
-    if (RUN_IN_JVM) {
-      return new double[] {valueLow, valueHigh};
-    } else {
-      return newLong0(valueLow, valueHigh);
-    }
-  }
-
-  private static int highBits(double[] a) {
-    return (int) (a[HIGH] / TWO_PWR_32_DBL);
-  }
-
-  private static double[] internalFromInt(int value) {
-    if (value >= 0) {
-      return createNormalized(value, 0.0);
-    } else {
-      return createNormalized(value + TWO_PWR_32_DBL, -TWO_PWR_32_DBL);
-    }
-  }
-
-  private static boolean isNegative(double[] a) {
-    return a[HIGH] < 0;
-  }
-
-  private static boolean isOdd(double[] a) {
-    return (lowBits(a) & 1) == 1;
-  }
-
-  private static boolean isZero(double[] a) {
-    return a[LOW] == 0.0 && a[HIGH] == 0.0;
-  }
-
-  private static int lowBits(double[] a) {
-    if (a[LOW] >= TWO_PWR_31_DBL) {
-      return (int) (a[LOW] - TWO_PWR_32_DBL);
-    } else {
-      return (int) a[LOW];
-    }
-  }
-
-  /**
-   * Make an instance equivalent to stringing highBits next to lowBits, where
-   * highBits and lowBits are assumed to be in 32-bit twos-complement notation.
-   * As a result, for any double[] l, the following identity holds:
-   * 
-   * <blockquote> <code>l == makeFromBits(l.highBits(), l.lowBits())</code>
-   * </blockquote>
-   */
-  private static double[] makeFromBits(int highBits, int lowBits) {
-    double high = highBits * TWO_PWR_32_DBL;
-    double low = lowBits;
-    if (lowBits < 0) {
-      low += TWO_PWR_32_DBL;
-    }
-    return createNormalized(low, high);
-  }
-
-  private static double[] multByMinValue(double[] a) {
-    if (isOdd(a)) {
-      return MIN_VALUE;
-    } else {
-      return ZERO;
-    }
-  }
-
-  /**
-   * Faster web mode implementation doesn't need full type semantics.
-   */
-  private static native double[] newLong0(double valueLow, double valueHigh) /*-{
-    return [valueLow, valueHigh];
-  }-*/;
-
-  /**
-   * Return a power of two as a double.
-   * 
-   * @return 2 raised to the <code>n</code>
-   */
-  private static double pwrAsDouble(int n) {
-    if (n <= 30) {
-      return (1 << n);
-    } else {
-      return pwrAsDouble(30) * pwrAsDouble(n - 30);
-    }
-  }
-
-  private static double toDoubleRoundDown(double[] a) {
-    int magnitute = (int) (Math.log(a[HIGH]) / LN_2);
-    if (magnitute <= PRECISION_BITS) {
-      return toDouble(a);
-    } else {
-      int diff = magnitute - PRECISION_BITS;
-      int toSubtract = (1 << diff) - 1;
-      return a[HIGH] + (a[LOW] - toSubtract);
-    }
-  }
-
-  private static double toDoubleRoundUp(double[] a) {
-    int magnitute = (int) (Math.log(a[HIGH]) / LN_2);
-    if (magnitute <= PRECISION_BITS) {
-      return toDouble(a);
-    } else {
-      int diff = magnitute - PRECISION_BITS;
-      int toAdd = (1 << diff) - 1;
-      return a[HIGH] + (a[LOW] + toAdd);
-    }
-  }
-
-  /**
-   * Web mode implementation; the long is already the right object.
-   */
-  @UnsafeNativeLong
-  private static native double[] typeChange0(long value) /*-{
-    return value;
-  }-*/;
-
+  
   /**
    * Not instantiable.
    */
   private LongLib() {
   }
-
 }
diff --git a/dev/core/super/com/google/gwt/lang/LongLibBase.java b/dev/core/super/com/google/gwt/lang/LongLibBase.java
new file mode 100644
index 0000000..f293f9c
--- /dev/null
+++ b/dev/core/super/com/google/gwt/lang/LongLibBase.java
@@ -0,0 +1,575 @@
+/*
+ * Copyright 2010 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.lang;
+
+import com.google.gwt.core.client.UnsafeNativeLong;
+
+final class LongEmul {
+  int l, m, h; // Used only when RUN_IN_JVM is true
+  
+  public static LongEmul getInstance() {
+    return new LongEmul();
+  }
+}
+
+/**
+ * Implements a Java <code>long</code> in a way that can be translated to
+ * JavaScript.  Methods that are meant to be called from outside this package
+ * are located in {@link LongLib}.
+ */
+class LongLibBase {
+  // Force the class to exist
+  public static LongEmul instance = new LongEmul();
+
+  /*
+   * Implementation: A LongEmul containing three values {l, m, h} (low, middle,
+   * high) such that (x.l + ((long) x.m << 22) + ((long) x.h << 44)) is equal to
+   * the original long integer.  The constant 22 is chosen since some browsers
+   * are faster when operating on integers of 24 bits or less.
+   * 
+   * By convention, we expect and maintain that the upper bits of each word
+   * be zeroed.
+   * 
+   * Note that this class must be careful using type "long". Being the
+   * implementation of the long type for web mode, any place it uses a long is
+   * not usable in web mode. There is currently one such method: {@link
+   * LongLib#getAsIntArray}.
+   */
+
+  // Note that the 'mul' method implicitly depends on the specific value
+  // BITS == 22
+  protected static final int BITS = 22;
+  protected static final int BITS01 = 2 * BITS;
+  protected static final int BITS2 = 64 - BITS01;
+  protected static final int MASK = (1 << BITS) - 1;
+  protected static final int MASK_2 = (1 << BITS2) - 1;
+  protected static LongEmul remainder;
+  
+  /**
+   * Allow a standalone Java test such as LongLibJreTest to run this code.
+   */
+  protected static boolean RUN_IN_JVM = false;
+  
+  protected static final int SIGN_BIT = BITS2 - 1;
+  protected static final int SIGN_BIT_VALUE = 1 << SIGN_BIT;
+  protected static final double TWO_PWR_15_DBL = 0x8000;
+  protected static final double TWO_PWR_16_DBL = 0x10000;
+  protected static final double TWO_PWR_22_DBL = 0x400000;
+  protected static final double TWO_PWR_31_DBL = TWO_PWR_16_DBL * TWO_PWR_15_DBL;
+  protected static final double TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
+  protected static final double TWO_PWR_44_DBL = TWO_PWR_22_DBL * TWO_PWR_22_DBL;
+  protected static final double TWO_PWR_63_DBL = TWO_PWR_32_DBL * TWO_PWR_31_DBL;
+
+  /**
+   * Web mode implementation; the int array is already the right object.
+   */
+  @UnsafeNativeLong
+  protected static native long asLong(LongEmul value) /*-{
+    return value;
+  }-*/;
+  
+  protected static LongEmul create(int value) {
+    int a0 = value & MASK;
+    int a1 = (value >> BITS) & MASK;
+    int a2 = (value < 0) ? MASK_2 : 0;
+
+    if (RUN_IN_JVM ) {
+      LongEmul a = new LongEmul();
+      a.l = a0;
+      a.m = a1;
+      a.h = a2;
+      return a;
+    }
+    return create0(a0, a1, a2);
+  }
+  
+  protected static LongEmul create(int a0, int a1, int a2) {
+    if (RUN_IN_JVM) {
+      LongEmul a = new LongEmul();
+      a.l = a0;
+      a.m = a1;
+      a.h = a2;
+      return a;
+    }
+    return create0(a0, a1, a2);
+  }
+  
+  protected static LongEmul divMod(LongEmul a, LongEmul b, boolean computeRemainder) {
+    if (isZero(b)) {
+      throw new ArithmeticException("divide by zero");
+    }
+    if (isZero(a)) {
+      if (computeRemainder) {
+        remainder = create(); // zero
+      }
+      return create(); // zero
+    }
+
+    // MIN_VALUE / MIN_VALUE = 1, anything other a / MIN_VALUE is 0
+    if (isMinValue(b)) {
+      return divModByMinValue(a, computeRemainder);
+    }
+
+    // Normalize b to abs(b), keeping track of the parity in 'negative'.
+    // We can do this because we have already ensured that b != MIN_VALUE.
+    boolean negative = false;
+    if (isNegative(b)) {
+      b = LongLib.neg(b);
+      negative = !negative;
+    }
+
+    // If b == 2^n, bpower will be n, otherwise it will be -1
+    int bpower = powerOfTwo(b);
+
+    // True if the original value of a is negative
+    boolean aIsNegative = false;
+    // True if the original value of a is Long.MIN_VALUE
+    boolean aIsMinValue = false;
+
+    /*
+     * Normalize a to a positive value, keeping track of the sign change
+     * in 'negative' (which tracks the sign of both a and b and is used to
+     * determine the sign of the quotient) and 'aIsNegative' (which is used
+     * to determine the sign of the remainder).
+     * 
+     * For all values of a except MIN_VALUE, we can just negate a and
+     * modify negative and aIsNegative appropriately.  When a == MIN_VALUE,
+     * negation is not possible without overflowing 64 bits, so instead
+     * of computing abs(MIN_VALUE) / abs(b) we compute
+     * (abs(MIN_VALUE) - 1) / abs(b).  The only circumstance under which
+     * these quotients differ is when b is a power of two, which will
+     * divide abs(MIN_VALUE) == 2^64 exactly.  In this case, we can get
+     * the proper result by shifting MIN_VALUE in unsigned fashion.
+     * 
+     * We make a single copy of a before the first operation that needs to
+     * modify its value.
+     */
+    boolean aIsCopy = false;
+    if (isMinValue(a)) {
+      aIsMinValue = true;
+      aIsNegative = true;
+      // If b is not a power of two, treat -a as MAX_VALUE (instead of the
+      // actual value (MAX_VALUE + 1)).
+      if (bpower == -1) {
+        a = create(LongLib.Const.MAX_VALUE);
+        aIsCopy = true;
+        negative = !negative;
+      } else {
+        // Signed shift of MIN_VALUE produces the right answer
+        LongEmul c = LongLib.shr(a, bpower);
+        if (negative) {
+          negate(c);
+        }
+        if (computeRemainder) {
+          remainder = create(); // zero
+        }
+        return c;
+      }
+    } else if (isNegative(a)) {
+      aIsNegative = true;
+      a = LongLib.neg(a);
+      aIsCopy = true;
+      negative = !negative;
+    }
+
+    // Now both a and b are non-negative
+    
+    // If b is a power of two, just shift
+    if (bpower != -1) {
+      return divModByShift(a, bpower, negative, aIsNegative,
+          computeRemainder);
+    }
+
+    // if a < b, the quotient is 0 and the remainder is a
+    if (LongLib.lt(a, b)) {
+      if (computeRemainder) {
+        if (aIsNegative) {
+          remainder = LongLib.neg(a);
+        } else {
+          remainder = create(a);
+        }
+      }
+      return create(); // zero
+    }
+    
+    // Generate the quotient using bit-at-a-time long division
+    return divModHelper(aIsCopy ? a : create(a), b, negative,
+        aIsNegative, aIsMinValue, computeRemainder);
+  }
+
+  protected static int getH(LongEmul a) {
+    if (RUN_IN_JVM) {
+      return a.h;
+    }
+    return getHNative(a);
+  }
+
+  protected static int getL(LongEmul a) {
+    if (RUN_IN_JVM) {
+      return a.l;
+    }
+    return getLNative(a);
+  }
+
+  protected static int getM(LongEmul a) {
+    if (RUN_IN_JVM) {
+      return a.m;
+    }
+    return getMNative(a);
+  }
+
+  protected static boolean isMinValue(LongEmul a) {
+    return getH(a) == SIGN_BIT_VALUE && getM(a) == 0 && getL(a) == 0;
+  }
+
+  protected static boolean isNegative(LongEmul a) {
+    return sign(a) != 0;
+  }
+
+  protected static boolean isZero(LongEmul a) {
+    return getL(a) == 0 && getM(a) == 0 && getH(a) == 0;
+  }
+
+  /**
+   * a = -a
+   */
+  protected static void negate(LongEmul a) {
+    int neg0 = (~getL(a) + 1) & MASK;
+    int neg1 = (~getM(a) + (neg0 == 0 ? 1 : 0)) & MASK;
+    int neg2 = (~getH(a) + ((neg0 == 0 && neg1 == 0) ? 1 : 0)) & MASK_2;
+
+    if (RUN_IN_JVM) {
+      a.l = neg0;
+      a.m = neg1;
+      a.h = neg2;
+    } else {
+      setL(a, neg0);
+      setM(a, neg1);
+      setH(a, neg2);
+    }
+  }
+
+  /**
+   * @return 0 if a is >= 0, 1 if a < 0.
+   */
+  protected static int sign(LongEmul a) {
+    return getH(a) >> (BITS2 - 1);
+  }
+
+  // Assumes a is non-negative
+  protected static double toDoubleHelper(LongEmul a) {
+    return getL(a) + (getM(a) * TWO_PWR_22_DBL) + (getH(a) * TWO_PWR_44_DBL);
+  }
+
+  /**
+   * Creates a long instance equal to 0.
+   */
+  private static LongEmul create() {
+    if (RUN_IN_JVM) {
+      return new LongEmul();
+    }
+    return create0(0, 0, 0);
+  }
+
+  /**
+   * Creates a long instance equal to a given long.
+   */
+  private static LongEmul create(LongEmul a) {
+    if (RUN_IN_JVM) {
+      LongEmul b = new LongEmul();
+      b.l = getL(a);
+      b.m = getM(a);
+      b.h = getH(a);
+      return b;
+    }
+    return create0(getL(a), getM(a), getH(a));
+  }
+
+  private static native LongEmul create0(int l, int m, int h) /*-{
+    return (a = @com.google.gwt.lang.LongEmul::getInstance()(), a.l = l, a.m = m, a.h = h, a);
+  }-*/;
+
+  private static LongEmul divModByMinValue(LongEmul a, boolean computeRemainder) {
+    // MIN_VALUE / MIN_VALUE == 1, remainder = 0
+    // (a != MIN_VALUE) / MIN_VALUE == 0, remainder == a
+    if (isMinValue(a)) {
+      if (computeRemainder) {
+        remainder = create(); // zero
+      }
+      return create(LongLib.Const.ONE);
+    }
+    if (computeRemainder) {
+      remainder = create(a);
+    }
+    return create(); // zero
+  }
+  
+  private static LongEmul divModByShift(LongEmul a, int bpower,
+      boolean negative, boolean aIsNegative, boolean computeRemainder) {
+    LongEmul c = LongLib.shr(a, bpower);
+    if (negative) {
+      negate(c);
+    }
+
+    if (computeRemainder) {
+      a = maskRight(a, bpower);
+      if (aIsNegative) {
+        remainder = LongLib.neg(a);
+      } else {
+        remainder = create(a);
+      }
+    }
+    return c;
+  }
+
+  private static LongEmul divModHelper(LongEmul a, LongEmul b, boolean negative,
+      boolean aIsNegative, boolean aIsMinValue, boolean computeRemainder) {
+    // Align the leading one bits of a and b by shifting b left
+    int shift = numberOfLeadingZeros(b) - numberOfLeadingZeros(a);
+    LongEmul bshift = LongLib.shl(b, shift);
+
+    LongEmul quotient = create();
+    while (shift >= 0) {
+      boolean gte = trialSubtract(a, bshift);
+      if (gte) {
+        setBit(quotient, shift);
+        if (isZero(a)) {
+          break;
+        }
+      }
+
+      toShru1(bshift);
+      shift--;
+    }
+
+    if (negative) {
+      negate(quotient);
+    }
+
+    if (computeRemainder) {
+      if (aIsNegative) {
+        remainder = LongLib.neg(a);
+        if (aIsMinValue) {
+          remainder = LongLib.sub(remainder, LongLib.Const.ONE);
+        }
+      } else {
+        remainder = create(a);
+      }
+    }
+
+    return quotient;
+  }
+
+  private static native int getHNative(LongEmul a) /*-{
+    return a.h;
+  }-*/;
+
+  private static native int getLNative(LongEmul a) /*-{
+    return a.l;
+  }-*/;
+
+  private static native int getMNative(LongEmul a) /*-{
+    return a.m;
+  }-*/;
+
+  /**
+   * a &= ((1L << bits) - 1)
+   */
+  private static LongEmul maskRight(LongEmul a, int bits) {
+    int b0, b1, b2;
+    if (bits <= BITS) {
+      b0 = getL(a) & ((1 << bits) - 1);
+      b1 = b2 = 0;
+    } else if (bits <= BITS01) {
+      b0 = getL(a);
+      b1 = getM(a) & ((1 << (bits - BITS)) - 1);
+      b2 = 0;
+    } else {
+      b0 = getL(a);
+      b1 = getM(a);
+      b2 = getH(a) & ((1 << (bits - BITS01)) - 1);
+    }
+
+    return create(b0, b1, b2);
+  }
+
+  /**
+   * Return the number of leading zeros of a long value.
+   */
+  private static int numberOfLeadingZeros(LongEmul a) {
+    int b2 = Integer.numberOfLeadingZeros(getH(a));
+    if (b2 == 32) {
+      int b1 = Integer.numberOfLeadingZeros(getM(a));
+      if (b1 == 32) {
+        return Integer.numberOfLeadingZeros(getL(a)) + BITS2 + 2 * BITS - 32;
+      } else {
+        return b1 + BITS2 - (32 - BITS);
+      }
+    } else {
+      return b2 - (32 - BITS2);
+    }
+  }
+
+  /**
+   * Return the exact log base 2 of a, or -1 if a is not a power of two: 
+   * 
+   * <pre>
+   * if (x == 2^n) {
+   *   return n;
+   * } else {
+   *   return -1;
+   * }
+   * </pre>
+   */
+  private static int powerOfTwo(LongEmul a) {
+    // Power of two or 0
+    int l = getL(a);
+    if ((l & (l - 1)) != 0) {
+      return -1;
+    }
+    int m = getM(a);
+    if ((m & (m - 1)) != 0) {
+      return -1;
+    }
+    int h = getH(a);
+    if ((h & (h - 1)) != 0) {
+      return -1;
+    }
+    if (h == 0 && m == 0 && l == 0) {
+      return -1;
+    }
+    if (h == 0 && m == 0 && l != 0) {
+      return Integer.numberOfTrailingZeros(l);
+    }
+    if (h == 0 && m != 0 && l == 0) {
+      return Integer.numberOfTrailingZeros(m) + BITS;
+    }
+    if (h != 0 && m == 0 && l == 0) {
+      return Integer.numberOfTrailingZeros(h) + BITS01;
+    }
+
+    return -1;
+  }
+
+  private static void setBit(LongEmul a, int bit) {
+    if (RUN_IN_JVM) {
+      if (bit < BITS) {
+        a.l |= 0x1 << bit;
+      } else if (bit < BITS01) {
+        a.m |= 0x1 << (bit - BITS);
+      } else {
+        a.h |= 0x1 << (bit - BITS01);
+      }
+    } else {
+      if (bit < BITS) {
+        setBitL(a, bit);
+      } else if (bit < BITS01) {
+        setBitM(a, bit - BITS);
+      } else {
+        setBitH(a, bit - BITS01);
+      }
+    }
+  }
+  
+  private static native void setBitH(LongEmul a, int bit) /*-{
+    a.h |= 1 << bit;
+  }-*/;
+  
+  private static native void setBitL(LongEmul a, int bit) /*-{
+    a.l |= 1 << bit;
+  }-*/;
+  
+  private static native void setBitM(LongEmul a, int bit) /*-{
+    a.m |= 1 << bit;
+  }-*/;
+
+  private static native void setH(LongEmul a, int x) /*-{
+    a.h = x;
+  }-*/;
+
+  private static native void setL(LongEmul a, int x) /*-{
+    a.l = x;
+  }-*/;
+
+  private static native void setM(LongEmul a, int x) /*-{
+    a.m = x;
+  }-*/;
+
+  /**
+   * a >>= 1.  Assumes a >= 0.
+   */
+  private static void toShru1(LongEmul a) {
+    int a1 = getM(a);
+    int a2 = getH(a);
+    int a0 = getL(a);
+
+    if (RUN_IN_JVM) {
+      a.h = a2 >>> 1;
+      a.m = (a1 >>> 1) | ((a2 & 0x1) << (BITS - 1));
+      a.l = (a0 >>> 1) | ((a1 & 0x1) << (BITS - 1));
+    } else {
+      setH(a, a2 >>> 1);
+      setM(a, (a1 >>> 1) | ((a2 & 0x1) << (BITS - 1)));
+      setL(a, (a0 >>> 1) | ((a1 & 0x1) << (BITS - 1)));
+    }
+  }
+
+  /**
+   * Attempt to subtract b from a if a >= b:
+   * 
+   * <pre>
+   * if (a >= b) {
+   *   a -= b;
+   *   return true;
+   * } else {
+   *   return false;
+   * }
+   * </pre>
+   */
+  private static boolean trialSubtract(LongEmul a, LongEmul b) {
+    // Early exit
+    int sum2 = getH(a) - getH(b);
+    if (sum2 < 0) {
+      return false;
+    }
+
+    int sum0 = getL(a) - getL(b);
+    int sum1 = getM(a) - getM(b) + (sum0 >> BITS);
+    sum2 += (sum1 >> BITS);
+
+    if (sum2 < 0) {
+      return false;
+    }
+
+    if (RUN_IN_JVM) {
+      a.l = sum0 & MASK;
+      a.m = sum1 & MASK;
+      a.h = sum2 & MASK_2;
+    } else {
+      setL(a, sum0 & MASK);
+      setM(a, sum1 & MASK);
+      setH(a, sum2 & MASK_2);
+    }
+
+    return true;
+  }
+
+  /**
+   * Not instantiable outside this package.
+   */
+  LongLibBase() {
+  }
+}
diff --git a/dev/core/test/com/google/gwt/lang/LongLibJreTest.java b/dev/core/test/com/google/gwt/lang/LongLibJreTest.java
index d8b5c85..559bdab 100644
--- a/dev/core/test/com/google/gwt/lang/LongLibJreTest.java
+++ b/dev/core/test/com/google/gwt/lang/LongLibJreTest.java
@@ -18,14 +18,14 @@
 import junit.framework.TestCase;
 
 /**
- * Test the LongLib class as a GWTTestCase.
+ * Test the LongLib class as a non-GWT TestCase.
  */
 public class LongLibJreTest extends TestCase {
-
+  
   static {
-    LongLib.RUN_IN_JVM = true;
+    LongLibBase.RUN_IN_JVM = true;
   }
-
+  
   private LongLibTestBase impl = new LongLibTestBase();
 
   public void testAAAA() {
diff --git a/dev/core/test/com/google/gwt/lang/LongLibTestBase.java b/dev/core/test/com/google/gwt/lang/LongLibTestBase.java
index bd0f38d..9f2052a 100644
--- a/dev/core/test/com/google/gwt/lang/LongLibTestBase.java
+++ b/dev/core/test/com/google/gwt/lang/LongLibTestBase.java
@@ -25,36 +25,36 @@
  */
 public class LongLibTestBase extends TestCase {
 
-  static void assertEquals(double[] expected, double[] actual) {
+  static void assertEquals(LongEmul expected, LongEmul actual) {
     assertTrue("expected=" + LongLib.toString(expected) + "  actual="
         + LongLib.toString(actual), LongLib.eq(expected, actual));
   }
 
   public void testAdditive() {
     {
-      final double[] n1 = LongLib.fromInt(1234);
-      final double[] n2 = LongLib.fromInt(9876);
+      final LongEmul n1 = LongLib.fromInt(1234);
+      final LongEmul n2 = LongLib.fromInt(9876);
       assertEquals(LongLib.fromInt(11110), LongLib.add(n1, n2));
       assertEquals(LongLib.fromInt(-8642), LongLib.sub(n1, n2));
     }
 
     {
-      final double[] n1 = LongLib.fromInt(-1234);
-      final double[] n2 = LongLib.fromInt(9876);
+      final LongEmul n1 = LongLib.fromInt(-1234);
+      final LongEmul n2 = LongLib.fromInt(9876);
       assertEquals(LongLib.fromInt(8642), LongLib.add(n1, n2));
       assertEquals(LongLib.fromInt(-11110), LongLib.sub(n1, n2));
     }
 
     {
-      final double[] n1 = LongLib.fromInt(-1234);
-      final double[] n2 = LongLib.fromInt(-9876);
+      final LongEmul n1 = LongLib.fromInt(-1234);
+      final LongEmul n2 = LongLib.fromInt(-9876);
       assertEquals(LongLib.fromInt(-11110), LongLib.add(n1, n2));
       assertEquals(LongLib.fromInt(8642), LongLib.sub(n1, n2));
     }
 
     {
-      final double[] n1 = longFromBits(0x12345678, 0xabcdabcd);
-      final double[] n2 = longFromBits(0x77773333, 0x22224444);
+      final LongEmul n1 = longFromBits(0x12345678, 0xabcdabcd);
+      final LongEmul n2 = longFromBits(0x77773333, 0x22224444);
       assertEquals(longFromBits(0x89ab89ab, 0xcdeff011), LongLib.add(n1, n2));
       assertEquals(longFromBits(0x9abd2345, 0x89ab6789), LongLib.sub(n1, n2));
     }
@@ -62,8 +62,8 @@
 
   public void testBitOps() {
     {
-      final double[] n1 = LongLib.fromInt(1234);
-      final double[] n2 = LongLib.fromInt(9876);
+      final LongEmul n1 = LongLib.fromInt(1234);
+      final LongEmul n2 = LongLib.fromInt(9876);
 
       assertEquals(LongLib.fromInt(1168), LongLib.and(n1, n2));
       assertEquals(LongLib.fromInt(9942), LongLib.or(n1, n2));
@@ -73,8 +73,8 @@
     }
 
     {
-      final double[] n1 = LongLib.fromInt(-1234);
-      final double[] n2 = LongLib.fromInt(9876);
+      final LongEmul n1 = LongLib.fromInt(-1234);
+      final LongEmul n2 = LongLib.fromInt(9876);
       assertEquals(LongLib.fromInt(8708), LongLib.and(n1, n2));
       assertEquals(LongLib.fromInt(-66), LongLib.or(n1, n2));
       assertEquals(LongLib.fromInt(-8774), LongLib.xor(n1, n2));
@@ -83,8 +83,8 @@
     }
 
     {
-      final double[] n1 = LongLib.shl(LongLib.fromInt(0x1234), 32);
-      final double[] n2 = LongLib.shl(LongLib.fromInt(0x9876), 32);
+      final LongEmul n1 = LongLib.shl(LongLib.fromInt(0x1234), 32);
+      final LongEmul n2 = LongLib.shl(LongLib.fromInt(0x9876), 32);
       assertEquals(LongLib.shl(LongLib.fromInt(0x1034), 32),
           LongLib.and(n1, n2));
       assertEquals(LongLib.shl(LongLib.fromInt(0x9a76), 32), LongLib.or(n1, n2));
@@ -113,17 +113,28 @@
     assertTrue(!LongLib.eq(LongLib.fromInt(12), LongLib.fromInt(11)));
     assertTrue(LongLib.gte(LongLib.fromInt(12), LongLib.fromInt(11)));
     assertTrue(LongLib.gt(LongLib.fromInt(12), LongLib.fromInt(11)));
+    
+    assertTrue(LongLib.gt(LongLib.fromInt(-10), LongLib.fromInt(-11)));
+    assertTrue(LongLib.gt(LongLib.fromInt(10), LongLib.fromInt(-11)));
+    assertTrue(!LongLib.gt(LongLib.fromInt(-10), LongLib.fromInt(11)));
+    assertTrue(LongLib.gte(LongLib.fromInt(-10), LongLib.fromInt(-11)));
+    assertTrue(LongLib.gte(LongLib.fromInt(-10), LongLib.fromInt(-10)));
+    assertTrue(!LongLib.lt(LongLib.fromInt(-10), LongLib.fromInt(-11)));
+    assertTrue(!LongLib.lte(LongLib.fromInt(-10), LongLib.fromInt(-11)));
+    assertTrue(LongLib.lte(LongLib.fromInt(-10), LongLib.fromInt(-10)));
+    assertTrue(LongLib.eq(LongLib.fromInt(-10), LongLib.fromInt(-10)));
+    assertTrue(!LongLib.neq(LongLib.fromInt(-10), LongLib.fromInt(-10)));
 
     // the following three comparisons cannot be implemented by
     // subtracting the arguments, because the subtraction causes an overflow
-    final double[] largeNeg = longFromBits(0x82341234, 0x0);
-    final double[] largePos = longFromBits(0x12341234, 0x0);
+    final LongEmul largeNeg = longFromBits(0x82341234, 0x0);
+    final LongEmul largePos = longFromBits(0x12341234, 0x0);
     assertTrue(LongLib.lt(largeNeg, largePos));
 
     assertTrue(LongLib.lt(Const.MIN_VALUE, LongLib.fromInt(0)));
     assertTrue(LongLib.gt(LongLib.fromInt(0), Const.MIN_VALUE));
 
-    final double[] largePosPlusOne = LongLib.add(largePos, LongLib.fromInt(1));
+    final LongEmul largePosPlusOne = LongLib.add(largePos, LongLib.fromInt(1));
 
     assertTrue(LongLib.lt(largePos, largePosPlusOne));
     assertTrue(LongLib.lte(largePos, largePosPlusOne));
@@ -152,22 +163,64 @@
   }
 
   public void testDiv() {
-    double[] deadBeef = LongLib.typeChange(0xdeadbeefdeadbeefL);
-    double[] ten = LongLib.fromInt(10);
-    assertEquals(LongLib.typeChange(-240105308887621659L), LongLib.div(
+    LongEmul deadBeef = longFromBits(0xdeadbeef, 0xdeadbeef);
+    LongEmul ten = LongLib.fromInt(10);
+    assertEquals(longFromBits(0xfcaaf97e, 0x63115fe5), LongLib.div(
         deadBeef, ten));
     assertEquals(Const.ZERO, LongLib.div(Const.ONE, Const.TWO));
-    assertEquals(LongLib.typeChange(4611686018427387903L), LongLib.div(
+    assertEquals(longFromBits(0x3fffffff, 0xffffffff), LongLib.div(
         Const.MAX_VALUE, Const.TWO));
+    
+    assertEquals(Const.ZERO, LongLib.div(Const.ZERO, LongLib.fromInt(1000)));
+    assertEquals(Const.ONE, LongLib.div(Const.MIN_VALUE, Const.MIN_VALUE));
+    assertEquals(Const.ZERO, LongLib.div(LongLib.fromInt(1000), Const.MIN_VALUE));
+    assertEquals("-1125899906842624", LongLib.toString(LongLib.div(Const.MIN_VALUE, LongLib.fromInt(8192))));
+    assertEquals("-1125762484664320", LongLib.toString(LongLib.div(Const.MIN_VALUE, LongLib.fromInt(8193))));
+    assertEquals(Const.ZERO, LongLib.div(LongLib.fromInt(-1000), LongLib.fromInt(8192)));
+    assertEquals(Const.ZERO, LongLib.div(LongLib.fromInt(-1000), LongLib.fromInt(8193)));
+    assertEquals(LongLib.fromInt(-122070), LongLib.div(LongLib.fromInt(-1000000000), LongLib.fromInt(8192)));
+    assertEquals(LongLib.fromInt(-122055), LongLib.div(LongLib.fromInt(-1000000000), LongLib.fromInt(8193)));
+    assertEquals(LongLib.fromInt(122070), LongLib.div(LongLib.fromInt(1000000000), LongLib.fromInt(8192)));
+    assertEquals(LongLib.fromInt(122055), LongLib.div(LongLib.fromInt(1000000000), LongLib.fromInt(8193)));
+    
+    assertEquals(longFromBits(0x1fffff, 0xffffffff), LongLib.div(Const.MAX_VALUE, longFromBits(0x00000000, 0x00000400)));
+    assertEquals(longFromBits(0x1fff, 0xffffffff), LongLib.div(Const.MAX_VALUE, longFromBits(0x00000000, 0x00040000)));
+    assertEquals(longFromBits(0x1f, 0xffffffff), LongLib.div(Const.MAX_VALUE, longFromBits(0x00000000, 0x04000000)));
+    assertEquals(LongLib.fromInt(536870911), LongLib.div(Const.MAX_VALUE, longFromBits(0x00000004, 0x00000000)));
+    assertEquals(LongLib.fromInt(2097151), LongLib.div(Const.MAX_VALUE, longFromBits(0x00000400, 0x00000000)));
+    assertEquals(LongLib.fromInt(8191), LongLib.div(Const.MAX_VALUE, longFromBits(0x00040000, 0x00000000)));
+    assertEquals(LongLib.fromInt(31), LongLib.div(Const.MAX_VALUE, longFromBits(0x04000000, 0x00000000)));
+    
+    LongLib.div(Const.MAX_VALUE, longFromBits(0x00000000, 0x00000300));
+    LongLib.div(Const.MAX_VALUE, longFromBits(0x00000000, 0x30000000));
+    LongLib.div(Const.MAX_VALUE, longFromBits(0x00300000, 0x00000000));
+    LongLib.div(Const.MAX_VALUE, longFromBits(0x00300000, 0x00000300));
+    LongLib.div(Const.MAX_VALUE, longFromBits(0x00300000, 0x30000000));
+    LongLib.div(Const.MAX_VALUE, longFromBits(0x00000000, 0x30000300));
+    LongLib.div(Const.MAX_VALUE, longFromBits(0x00300000, 0x30000300));
   }
 
   public void testFactorial() {
-    double[] fact18 = fact(LongLib.fromInt(18));
-    double[] fact17 = fact(LongLib.fromInt(17));
+    LongEmul fact18 = fact(LongLib.fromInt(18));
+    LongEmul fact17 = fact(LongLib.fromInt(17));
     assertEquals(LongLib.fromInt(18), LongLib.div(fact18, fact17));
   }
 
   public void testFromDouble() {
+    assertEquals("4611686018427387904", LongLib.toString(LongLib.fromDouble(Math.pow(2, 62))));
+    assertEquals("35184372088832", LongLib.toString(LongLib.fromDouble(Math.pow(2, 45))));
+    assertEquals("35184372088832", LongLib.toString(LongLib.fromDouble(Math.pow(2, 45))));
+    assertEquals("17592186044417", LongLib.toString(LongLib.fromDouble(Math.pow(2, 44) + 1)));
+    assertEquals("17592186044416", LongLib.toString(LongLib.fromDouble(Math.pow(2, 44))));
+    assertEquals("17592186044415", LongLib.toString(LongLib.fromDouble(Math.pow(2, 44) - 1)));
+    assertEquals("8796093022208", LongLib.toString(LongLib.fromDouble(Math.pow(2, 43))));
+    assertEquals(LongLib.fromInt(8388608), LongLib.fromDouble(Math.pow(2, 23)));
+    assertEquals(LongLib.fromInt(4194305), LongLib.fromDouble(Math.pow(2, 22) + 1));
+    assertEquals(LongLib.fromInt(4194304), LongLib.fromDouble(Math.pow(2, 22)));
+    assertEquals(LongLib.fromInt(4194303), LongLib.fromDouble(Math.pow(2, 22) - 1));
+    assertEquals(LongLib.fromInt(2097152), LongLib.fromDouble(Math.pow(2, 21)));
+    assertEquals(LongLib.fromInt(1048576), LongLib.fromDouble(Math.pow(2, 20)));
+    
     // these tests are based on JLS3, section 5.1.3
 
     assertEquals(LongLib.fromInt(10), LongLib.fromDouble(10.5));
@@ -190,6 +243,28 @@
     assertEquals(Const.MAX_VALUE, LongLib.neg(LongLib.add(Const.MIN_VALUE,
         LongLib.fromInt(1))));
   }
+  
+  public void testMod() {
+    assertEquals(LongLib.fromInt(0), LongLib.mod(Const.ZERO, LongLib.fromInt(1000)));
+    assertEquals(LongLib.fromInt(0), LongLib.mod(Const.MIN_VALUE, Const.MIN_VALUE));
+    assertEquals(LongLib.fromInt(1000), LongLib.mod(LongLib.fromInt(1000), Const.MIN_VALUE));
+    assertEquals(LongLib.fromInt(0), LongLib.mod(Const.MIN_VALUE, LongLib.fromInt(8192)));
+    assertEquals(LongLib.fromInt(-2048), LongLib.mod(Const.MIN_VALUE, LongLib.fromInt(8193)));
+    assertEquals(LongLib.fromInt(-1000), LongLib.mod(LongLib.fromInt(-1000), LongLib.fromInt(8192)));
+    assertEquals(LongLib.fromInt(-1000), LongLib.mod(LongLib.fromInt(-1000), LongLib.fromInt(8193)));
+    assertEquals(LongLib.fromInt(-2560), LongLib.mod(LongLib.fromInt(-1000000000), LongLib.fromInt(8192)));
+    assertEquals(LongLib.fromInt(-3385), LongLib.mod(LongLib.fromInt(-1000000000), LongLib.fromInt(8193)));
+    assertEquals(LongLib.fromInt(2560), LongLib.mod(LongLib.fromInt(1000000000), LongLib.fromInt(8192)));
+    assertEquals(LongLib.fromInt(3385), LongLib.mod(LongLib.fromInt(1000000000), LongLib.fromInt(8193)));
+    
+    assertEquals(longFromBits(0x0, 0x3ff), LongLib.mod(Const.MAX_VALUE, longFromBits(0x00000000, 0x00000400)));
+    assertEquals(longFromBits(0x0, 0x3ffff), LongLib.mod(Const.MAX_VALUE, longFromBits(0x00000000, 0x00040000)));
+    assertEquals(longFromBits(0x0, 0x3ffffff), LongLib.mod(Const.MAX_VALUE, longFromBits(0x00000000, 0x04000000)));
+    assertEquals(longFromBits(0x3, 0xffffffff), LongLib.mod(Const.MAX_VALUE, longFromBits(0x00000004, 0x00000000)));
+    assertEquals(longFromBits(0x3ff, 0xffffffff), LongLib.mod(Const.MAX_VALUE, longFromBits(0x00000400, 0x00000000)));
+    assertEquals(longFromBits(0x3ffff, 0xffffffff), LongLib.mod(Const.MAX_VALUE, longFromBits(0x00040000, 0x00000000)));
+    assertEquals(longFromBits(0x3ffffff, 0xffffffff), LongLib.mod(Const.MAX_VALUE, longFromBits(0x04000000, 0x00000000)));
+  }
 
   public void testMultiplicative() {
     assertEquals(LongLib.fromInt(3333), LongLib.mul(LongLib.fromInt(1111),
@@ -282,7 +357,7 @@
 
     assertEquals(LongLib.fromInt(-1 << 5), LongLib.shl(LongLib.fromInt(-1), 5));
     assertEquals(LongLib.fromInt(-1), LongLib.shl(LongLib.fromInt(-1), 0));
-    assertEquals(LongLib.neg(LongLib.typeChange(0x4000000000000000L)),
+    assertEquals(LongLib.neg(longFromBits(0x40000000, 0x00000000)),
         LongLib.shr(LongLib.shl(LongLib.fromInt(1), 63), 1));
     assertEquals(LongLib.fromInt(0), LongLib.shl(LongLib.shl(
         LongLib.fromInt(-1), 32), 32));
@@ -292,12 +367,89 @@
         LongLib.neg(longFromBits(8, 0)), 1));
     assertEquals(longFromBits(0x7ffffffc, 0x0), LongLib.shru(
         LongLib.neg(longFromBits(8, 0)), 1));
+    
+    assertEquals(longFromBits(0x00723456, 0x789abcde), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcdef0), 8));
+    assertEquals(longFromBits(0x00007234, 0x56789abc), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcdef0), 16));
+    assertEquals(longFromBits(0x00000072, 0x3456789a), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcdef0), 24));
+    assertEquals(longFromBits(0x00000007, 0x23456789), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcdef0), 28));
+    assertEquals(longFromBits(0x00000000, 0x72345678), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcdef0), 32));
+    assertEquals(longFromBits(0x00000000, 0x07234567), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcdef0), 36));
+    assertEquals(longFromBits(0x00000000, 0x00723456), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcdef0), 40));
+    assertEquals(longFromBits(0x00000000, 0x00072345), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcde00), 44));
+    assertEquals(longFromBits(0x00000000, 0x00007234), LongLib.shr(
+        longFromBits(0x72345678, 0x9abcdef0), 48));
+    
+    assertEquals(longFromBits(0x00723456, 0x789abcde), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcdef0), 8));
+    assertEquals(longFromBits(0x00007234, 0x56789abc), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcdef0), 16));
+    assertEquals(longFromBits(0x00000072, 0x3456789a), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcdef0), 24));
+    assertEquals(longFromBits(0x00000007, 0x23456789), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcdef0), 28));
+    assertEquals(longFromBits(0x00000000, 0x72345678), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcdef0), 32));
+    assertEquals(longFromBits(0x00000000, 0x07234567), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcdef0), 36));
+    assertEquals(longFromBits(0x00000000, 0x00723456), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcdef0), 40));
+    assertEquals(longFromBits(0x00000000, 0x00072345), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcde00), 44));
+    assertEquals(longFromBits(0x00000000, 0x00007234), LongLib.shru(
+        longFromBits(0x72345678, 0x9abcdef0), 48));
+    
+    assertEquals(longFromBits(0xff923456, 0x789abcde), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 8));
+    assertEquals(longFromBits(0xffff9234, 0x56789abc), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 16));
+    assertEquals(longFromBits(0xffffff92, 0x3456789a), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 24));
+    assertEquals(longFromBits(0xfffffff9, 0x23456789), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 28));
+    assertEquals(longFromBits(0xffffffff, 0x92345678), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 32));
+    assertEquals(longFromBits(0xffffffff, 0xf9234567), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 36));
+    assertEquals(longFromBits(0xffffffff, 0xff923456), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 40));
+    assertEquals(longFromBits(0xffffffff, 0xfff92345), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 44));
+    assertEquals(longFromBits(0xffffffff, 0xffff9234), LongLib.shr(
+        longFromBits(0x92345678, 0x9abcdef0), 48));
+    
+    assertEquals(longFromBits(0x00923456, 0x789abcde), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 8));
+    assertEquals(longFromBits(0x00009234, 0x56789abc), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 16));
+    assertEquals(longFromBits(0x00000092, 0x3456789a), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 24));
+    assertEquals(longFromBits(0x00000009, 0x23456789), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 28));
+    assertEquals(longFromBits(0x00000000, 0x92345678), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 32));
+    assertEquals(longFromBits(0x00000000, 0x09234567), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 36));
+    assertEquals(longFromBits(0x00000000, 0x00923456), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 40));
+    assertEquals(longFromBits(0x00000000, 0x00092345), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 44));
+    assertEquals(longFromBits(0x00000000, 0x00009234), LongLib.shru(
+        longFromBits(0x92345678, 0x9abcdef0), 48));
   }
 
   // Issue 1198, and also a good exercise of several methods.
   public void testToHexString() {
-    double[] deadbeaf12341234 = longFromBits(0xdeadbeaf, 0x12341234);
+    LongEmul deadbeaf12341234 = longFromBits(0xdeadbeaf, 0x12341234);
 
+    assertEquals("0", toHexString(Const.ZERO));
     assertEquals("deadbeaf12341234", toHexString(deadbeaf12341234));
   }
 
@@ -310,14 +462,14 @@
 
     int top = 922337201;
     int bottom = 967490662;
-    double[] fullnum = LongLib.add(LongLib.mul(LongLib.fromInt(1000000000),
+    LongEmul fullnum = LongLib.add(LongLib.mul(LongLib.fromInt(1000000000),
         LongLib.fromInt(top)), LongLib.fromInt(bottom));
 
     assertEquals("922337201967490662", LongLib.toString(fullnum));
     assertEquals("-922337201967490662", LongLib.toString(LongLib.neg(fullnum)));
   }
 
-  private double[] fact(double[] n) {
+  private LongEmul fact(LongEmul n) {
     if (LongLib.eq(n, LongLib.fromInt(0))) {
       return LongLib.fromInt(1);
     } else {
@@ -325,19 +477,18 @@
     }
   }
 
-  private double[] longFromBits(int top, int bottom) {
-    double[] topHalf = LongLib.shl(LongLib.fromInt(top), 32);
-    double[] bottomHalf = LongLib.fromInt(bottom);
+  private LongEmul longFromBits(int top, int bottom) {
+    LongEmul topHalf = LongLib.shl(LongLib.fromInt(top), 32);
+    LongEmul bottomHalf = LongLib.fromInt(bottom);
     if (LongLib.lt(bottomHalf, Const.ZERO)) {
       bottomHalf = LongLib.add(bottomHalf, LongLib.shl(LongLib.fromInt(1), 32));
     }
-    double[] total = LongLib.add(topHalf, bottomHalf);
+    LongEmul total = LongLib.add(topHalf, bottomHalf);
     return total;
   }
 
-  private String toHexString(double[] x) {
-    // copied from the GWT Long class and modified for double[]
-    double[] zero = LongLib.fromInt(0);
+  private String toHexString(LongEmul x) {
+    LongEmul zero = LongLib.fromInt(0);
 
     if (LongLib.eq(x, zero)) {
       return "0";
diff --git a/tools/api-checker/config/gwt20_21userApi.conf b/tools/api-checker/config/gwt20_21userApi.conf
index 1959dcd..43801d2 100644
--- a/tools/api-checker/config/gwt20_21userApi.conf
+++ b/tools/api-checker/config/gwt20_21userApi.conf
@@ -109,3 +109,32 @@
 
 # Removing HTTPRequest.
 com.google.gwt.user.client.HTTPRequest MISSING
+
+# Change signature for native long from double[2] to LongEmul{l=int,m=int,h=int} 
+com.google.gwt.lang.LongLib::RUN_IN_JVM MISSING
+com.google.gwt.lang.LongLib::add([D[D) MISSING
+com.google.gwt.lang.LongLib::and([D[D) MISSING
+com.google.gwt.lang.LongLib::compare([D[D) MISSING
+com.google.gwt.lang.LongLib::div([D[D) MISSING
+com.google.gwt.lang.LongLib::eq([D[D) MISSING
+com.google.gwt.lang.LongLib::fromDouble(D) RETURN_TYPE_ERROR  from double[] to java.lang.Object
+com.google.gwt.lang.LongLib::fromInt(I) RETURN_TYPE_ERROR  from double[] to java.lang.Object
+com.google.gwt.lang.LongLib::gt([D[D) MISSING
+com.google.gwt.lang.LongLib::gte([D[D) MISSING
+com.google.gwt.lang.LongLib::lt([D[D) MISSING
+com.google.gwt.lang.LongLib::lte([D[D) MISSING
+com.google.gwt.lang.LongLib::mod([D[D) MISSING
+com.google.gwt.lang.LongLib::mul([D[D) MISSING
+com.google.gwt.lang.LongLib::neg([D) MISSING
+com.google.gwt.lang.LongLib::neq([D[D) MISSING
+com.google.gwt.lang.LongLib::not([D) MISSING
+com.google.gwt.lang.LongLib::or([D[D) MISSING
+com.google.gwt.lang.LongLib::shl([DI) MISSING
+com.google.gwt.lang.LongLib::shr([DI) MISSING
+com.google.gwt.lang.LongLib::shru([DI) MISSING
+com.google.gwt.lang.LongLib::sub([D[D) MISSING
+com.google.gwt.lang.LongLib::toDouble([D) MISSING
+com.google.gwt.lang.LongLib::toInt([D) MISSING
+com.google.gwt.lang.LongLib::toString([D) MISSING
+com.google.gwt.lang.LongLib::typeChange(J) MISSING
+com.google.gwt.lang.LongLib::xor([D[D) MISSING
diff --git a/user/src/com/google/gwt/rpc/client/impl/CommandClientSerializationStreamReader.java b/user/src/com/google/gwt/rpc/client/impl/CommandClientSerializationStreamReader.java
index 83586a0..39e61eb 100644
--- a/user/src/com/google/gwt/rpc/client/impl/CommandClientSerializationStreamReader.java
+++ b/user/src/com/google/gwt/rpc/client/impl/CommandClientSerializationStreamReader.java
@@ -65,6 +65,7 @@
 
   @UnsafeNativeLong
   private static native long readLong0(JavaScriptObject obj, int idx) /*-{
+    // TODO (rice): use backwards-compatible wire format?
     return obj[idx];
   }-*/;
 
diff --git a/user/src/com/google/gwt/rpc/client/impl/CommandClientSerializationStreamWriter.java b/user/src/com/google/gwt/rpc/client/impl/CommandClientSerializationStreamWriter.java
index 83c69ee..2085fbc 100644
--- a/user/src/com/google/gwt/rpc/client/impl/CommandClientSerializationStreamWriter.java
+++ b/user/src/com/google/gwt/rpc/client/impl/CommandClientSerializationStreamWriter.java
@@ -197,8 +197,7 @@
       value.valueOf && (value = value.valueOf());
 
       // See if the value is our web-mode representation of a long
-      if (!value.@java.lang.Object::typeMarker && value.length && 
-          value.length == 2 && (typeof value[0] == 'number') && (typeof value[1] == 'number')) {
+      if (value.hasOwnProperty('l') && value.hasOwnProperty('m') && value.hasOwnProperty('h')) {
         type = 'long';
       }
     }
diff --git a/user/src/com/google/gwt/rpc/server/WebModePayloadSink.java b/user/src/com/google/gwt/rpc/server/WebModePayloadSink.java
index e8b0d20..5519572 100644
--- a/user/src/com/google/gwt/rpc/server/WebModePayloadSink.java
+++ b/user/src/com/google/gwt/rpc/server/WebModePayloadSink.java
@@ -43,7 +43,6 @@
 import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;
 import com.google.gwt.user.client.rpc.SerializationException;
 import com.google.gwt.user.client.rpc.SerializationStreamReader;
-import com.google.gwt.user.client.rpc.impl.AbstractSerializationStreamWriter;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -167,21 +166,21 @@
 
     @Override
     public void endVisit(LongValueCommand x, Context ctx) {
+      // TODO (rice): use backwards-compatible wire format?
       long fieldValue = x.getValue();
-
+      
       /*
-       * Client code represents longs internally as an array of two Numbers. In
-       * order to make serialization of longs faster, we'll send the component
-       * parts so that the value can be directly reconstituted on the client.
+       * Client code represents longs internally as an Object with numeric
+       * properties l, m, and h. In order to make serialization of longs faster,
+       * we'll send the component parts so that the value can be directly
+       * reconstituted on the client.
        */
-      double[] parts = AbstractSerializationStreamWriter.makeLongComponents(
-          (int) (fieldValue >> 32), (int) fieldValue);
-      assert parts.length == 2;
-      lbracket();
-      push(String.valueOf(parts[0]));
-      comma();
-      push(String.valueOf(parts[1]));
-      rbracket();
+      int l = (int) (fieldValue & 0x3fffff);
+      int m = (int) ((fieldValue >> 22) & 0x3fffff);
+      int h = (int) ((fieldValue >> 44) & 0xfffff);
+      // CHECKSTYLE_OFF
+      push("{l:" + l + ",m:" + m + ",h:" + h + "}");
+      // CHECKSTYLE_ON
     }
 
     @Override
diff --git a/user/src/com/google/gwt/user/client/rpc/impl/AbstractSerializationStreamReader.java b/user/src/com/google/gwt/user/client/rpc/impl/AbstractSerializationStreamReader.java
index 2ed7015..3766b5d 100644
--- a/user/src/com/google/gwt/user/client/rpc/impl/AbstractSerializationStreamReader.java
+++ b/user/src/com/google/gwt/user/client/rpc/impl/AbstractSerializationStreamReader.java
@@ -27,6 +27,59 @@
  */
 public abstract class AbstractSerializationStreamReader extends
     AbstractSerializationStream implements SerializationStreamReader {
+  
+  private static final double TWO_PWR_15_DBL = 0x8000;
+  private static final double TWO_PWR_16_DBL = 0x10000;
+  private static final double TWO_PWR_22_DBL = 0x400000;
+  private static final double TWO_PWR_31_DBL = TWO_PWR_16_DBL * TWO_PWR_15_DBL;
+  private static final double TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
+  private static final double TWO_PWR_44_DBL = TWO_PWR_22_DBL * TWO_PWR_22_DBL;
+  private static final double TWO_PWR_63_DBL = TWO_PWR_32_DBL * TWO_PWR_31_DBL;
+
+  /**
+   * Return a long from a pair of doubles { low, high } such that the
+   * actual value is equal to high + low.
+   */
+  public static long fromDoubles(double lowDouble, double highDouble) {
+    long high = fromDouble(highDouble);
+    long low = fromDouble(lowDouble);
+    return high + low;
+  }
+
+  private static long fromDouble(double value) {
+    if (Double.isNaN(value)) {
+      return 0L;
+    }
+    if (value < -TWO_PWR_63_DBL) {
+      return Long.MIN_VALUE;
+    }
+    if (value >= TWO_PWR_63_DBL) {
+      return Long.MAX_VALUE;
+    }
+  
+    boolean negative = false;
+    if (value < 0) {
+      negative = true;
+      value = -value;
+    }
+    int a2 = 0;
+    if (value >= TWO_PWR_44_DBL) {
+      a2 = (int) (value / TWO_PWR_44_DBL);
+      value -= a2 * TWO_PWR_44_DBL;
+    }
+    int a1 = 0;
+    if (value >= TWO_PWR_22_DBL) {
+      a1 = (int) (value / TWO_PWR_22_DBL);
+      value -= a1 * TWO_PWR_22_DBL;
+    }
+    int a0 = (int) value;
+    
+    long result = ((long) a2 << 44) | ((long) a1 << 22) | a0;
+    if (negative) {
+      result = -result;
+    }
+    return result;
+  }
 
   private ArrayList<Object> seenArray = new ArrayList<Object>();
 
@@ -96,5 +149,4 @@
     // index is 1-based
     return seenArray.size();
   }
-
 }
diff --git a/user/src/com/google/gwt/user/client/rpc/impl/AbstractSerializationStreamWriter.java b/user/src/com/google/gwt/user/client/rpc/impl/AbstractSerializationStreamWriter.java
index 52e75e4..b245553 100644
--- a/user/src/com/google/gwt/user/client/rpc/impl/AbstractSerializationStreamWriter.java
+++ b/user/src/com/google/gwt/user/client/rpc/impl/AbstractSerializationStreamWriter.java
@@ -33,22 +33,17 @@
 public abstract class AbstractSerializationStreamWriter extends
     AbstractSerializationStream implements SerializationStreamWriter {
 
-  // Keep synchronized with LongLib
   private static final double TWO_PWR_16_DBL = 0x10000;
-
-  // Keep synchronized with LongLib
   private static final double TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
 
   /**
-   * Make an instance equivalent to stringing highBits next to lowBits, where
-   * highBits and lowBits are assumed to be in 32-bit twos-complement notation.
-   * As a result, for any double[] l, the following identity holds:
-   * 
-   * <blockquote> <code>l == makeFromBits(l.highBits(), l.lowBits())</code>
-   * </blockquote>
+   * Return a pair of doubles { low, high } that add up to the given number,
+   * such that "low" is always between 0 and 2^32-1 inclusive and "high" is
+   * always between -2^63 and 2^63-2^32 inclusive and is a multiple of 2^32.
    */
-  // Keep synchronized with LongLib
-  public static double[] makeLongComponents(int highBits, int lowBits) {
+  public static double[] getAsDoubleArray(long value) {
+    int lowBits = (int) (value & 0xffffffff);
+    int highBits = (int) (value >> 32);
     double high = highBits * TWO_PWR_32_DBL;
     double low = lowBits;
     if (lowBits < 0) {
@@ -211,5 +206,4 @@
    */
   protected abstract void serialize(Object instance, String typeSignature)
       throws SerializationException;
-
 }
diff --git a/user/src/com/google/gwt/user/client/rpc/impl/ClientSerializationStreamReader.java b/user/src/com/google/gwt/user/client/rpc/impl/ClientSerializationStreamReader.java
index 748f4b3..f1bb0e1 100644
--- a/user/src/com/google/gwt/user/client/rpc/impl/ClientSerializationStreamReader.java
+++ b/user/src/com/google/gwt/user/client/rpc/impl/ClientSerializationStreamReader.java
@@ -17,7 +17,6 @@
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.core.client.JavaScriptObject;
-import com.google.gwt.core.client.UnsafeNativeLong;
 import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;
 import com.google.gwt.user.client.rpc.SerializationException;
 
@@ -35,11 +34,6 @@
     return array.length;
   }-*/;
 
-  @UnsafeNativeLong
-  private static native long readLong0(double low, double high) /*-{
-    return [low, high];
-  }-*/;
-
   int index;
 
   JavaScriptObject results;
@@ -92,10 +86,12 @@
   }-*/;
 
   public long readLong() {
+    double low = readDouble();
+    double high = readDouble();
     if (GWT.isScript()) {
-      return readLong0(readDouble(), readDouble());
+      return fromDoubles(low, high);
     } else {
-      return (long) readDouble() + (long) readDouble();
+      return (long) low + (long) high;
     }
   }
 
diff --git a/user/src/com/google/gwt/user/client/rpc/impl/ClientSerializationStreamWriter.java b/user/src/com/google/gwt/user/client/rpc/impl/ClientSerializationStreamWriter.java
index 291e877..584d695 100644
--- a/user/src/com/google/gwt/user/client/rpc/impl/ClientSerializationStreamWriter.java
+++ b/user/src/com/google/gwt/user/client/rpc/impl/ClientSerializationStreamWriter.java
@@ -15,9 +15,7 @@
  */
 package com.google.gwt.user.client.rpc.impl;
 
-import com.google.gwt.core.client.GWT;
 import com.google.gwt.core.client.JavaScriptObject;
-import com.google.gwt.core.client.UnsafeNativeLong;
 import com.google.gwt.user.client.rpc.SerializationException;
 
 import java.util.List;
@@ -102,12 +100,6 @@
     }
   }-*/;
 
-  @UnsafeNativeLong
-  // Keep synchronized with LongLib
-  private static native double[] makeLongComponents0(long value) /*-{
-    return value;
-  }-*/;
-
   private StringBuffer encodeBuffer;
 
   private final String moduleBaseURL;
@@ -157,18 +149,9 @@
 
   @Override
   public void writeLong(long fieldValue) {
-    /*
-     * Client code represents longs internally as an array of two Numbers. In
-     * order to make serialization of longs faster, we'll send the component
-     * parts so that the value can be directly reconstituted on the server.
-     */
-    double[] parts;
-    if (GWT.isScript()) {
-      parts = makeLongComponents0(fieldValue);
-    } else {
-      parts = makeLongComponents((int) (fieldValue >> 32), (int) fieldValue);
-    }
-    assert parts.length == 2;
+    // Write longs as a pair of doubles for backwards compatibility
+    double[] parts = getAsDoubleArray(fieldValue);
+    assert parts != null && parts.length == 2;
     writeDouble(parts[0]);
     writeDouble(parts[1]);
   }
diff --git a/user/src/com/google/gwt/user/server/rpc/impl/ServerSerializationStreamWriter.java b/user/src/com/google/gwt/user/server/rpc/impl/ServerSerializationStreamWriter.java
index 7bba2cb..3c21899 100644
--- a/user/src/com/google/gwt/user/server/rpc/impl/ServerSerializationStreamWriter.java
+++ b/user/src/com/google/gwt/user/server/rpc/impl/ServerSerializationStreamWriter.java
@@ -555,16 +555,11 @@
 
     return stream.toString();
   }
-
+  
   public void writeLong(long fieldValue) {
-    /*
-     * Client code represents longs internally as an array of two Numbers. In
-     * order to make serialization of longs faster, we'll send the component
-     * parts so that the value can be directly reconstituted on the client.
-     */
-    double[] parts = makeLongComponents((int) (fieldValue >> 32),
-        (int) fieldValue);
-    assert parts.length == 2;
+    // Write longs as a pair of doubles for backwards compatibility
+    double[] parts = getAsDoubleArray(fieldValue);
+    assert parts != null && parts.length == 2;
     writeDouble(parts[0]);
     writeDouble(parts[1]);
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/Integer.java b/user/super/com/google/gwt/emul/java/lang/Integer.java
index aa4ed50..6a44ab6 100644
--- a/user/super/com/google/gwt/emul/java/lang/Integer.java
+++ b/user/super/com/google/gwt/emul/java/lang/Integer.java
@@ -88,12 +88,37 @@
   }
 
   public static int numberOfLeadingZeros(int i) {
+    // Based on Henry S. Warren, Jr: "Hacker's Delight", p. 80.
     if (i < 0) {
       return 0;
     } else if (i == 0) {
       return SIZE;
     } else {
-      return SIZE - 1 - (int) Math.floor(Math.log(i) / Math.log(2.0d));
+      int y, m, n;
+
+      y = -(i >> 16);
+      m = (y >> 16) & 16;
+      n = 16 - m;
+      i = i >> m;
+
+      y = i - 0x100;
+      m = (y >> 16) & 8;
+      n += m;
+      i <<= m;
+
+      y = i - 0x1000;
+      m = (y >> 16) & 4;
+      n += m;
+      i <<= m;
+
+      y = i - 0x4000;
+      m = (y >> 16) & 2;
+      n += m; 
+      i <<= m;
+
+      y = i >> 14;
+      m = y & ~(y >> 1);
+      return n + 2 - m;
     }
   }
 
diff --git a/user/super/com/google/gwt/emul/java/lang/Long.java b/user/super/com/google/gwt/emul/java/lang/Long.java
index 913fab7..0971d94 100644
--- a/user/super/com/google/gwt/emul/java/lang/Long.java
+++ b/user/super/com/google/gwt/emul/java/lang/Long.java
@@ -103,62 +103,11 @@
   public static long parseLong(String s) throws NumberFormatException {
     return parseLong(s, 10);
   }
-
-  public static long parseLong(String orig, int intRadix)
-      throws NumberFormatException {
-    if (orig == null) {
-      throw new NumberFormatException("null");
-    }
-    if (orig.length() == 0) {
-      throw NumberFormatException.forInputString(orig);
-    }
-
-    if (intRadix < Character.MIN_RADIX || intRadix > Character.MAX_RADIX) {
-      throw new NumberFormatException("radix " + intRadix + " out of range");
-    }
-
-    boolean neg = false;
-    String s;
-    if (orig.charAt(0) == '-') {
-      neg = true;
-      s = orig.substring(1);
-      if (s.equals("")) { // orig = "-"
-        throw NumberFormatException.forInputString(orig);
-      }
-    } else {
-      s = orig;
-    }
-
-    long result = 0;
-    if (intRadix == 16) {
-      result = parseHex(s);
-    } else {
-      // Cache a converted version for performance (pure long ops are faster).
-      long radix = intRadix;
-      for (int i = 0, len = s.length(); i < len; ++i) {
-        if (result < 0) {
-          throw NumberFormatException.forInputString(s);
-        }
-        result *= radix;
-        char c = s.charAt(i);
-        int value = Character.digit(c, intRadix);
-        if (value < 0) {
-          throw NumberFormatException.forInputString(s);
-        }
-        result += value;
-      }
-    }
-
-    if (result < 0 && result != MIN_VALUE) {
-      throw NumberFormatException.forInputString(s);
-    }
-    if (neg) {
-      return -result;
-    } else {
-      return result;
-    }
+  
+  public static long parseLong(String s, int radix) throws NumberFormatException {
+    return __parseAndValidateLong(s, radix);
   }
-
+ 
   public static long reverse(long i) {
     int high = (int) (i >>> 32);
     int low = (int) i;
@@ -377,5 +326,4 @@
   public String toString() {
     return toString(value);
   }
-
 }
diff --git a/user/super/com/google/gwt/emul/java/lang/Number.java b/user/super/com/google/gwt/emul/java/lang/Number.java
index 810df15..32ada57 100644
--- a/user/super/com/google/gwt/emul/java/lang/Number.java
+++ b/user/super/com/google/gwt/emul/java/lang/Number.java
@@ -53,6 +53,89 @@
   }
 
   /**
+   * Use nested class to avoid clinit on outer.
+   */
+  static class __ParseLong {
+    /**
+     * The number of digits (excluding minus sign and leading zeros) to process
+     * at a time.  The largest value expressible in maxDigits digits as well as
+     * the factor radix^maxDigits must be strictly less than 2^31.
+     */
+    private static final int[] maxDigitsForRadix = {-1, -1, // unused
+      30, // base 2
+      19, // base 3
+      15, // base 4
+      13, // base 5
+      11, 11, // base 6-7
+      10, // base 8
+      9, 9, // base 9-10
+      8, 8, 8, 8, // base 11-14
+      7, 7, 7, 7, 7, 7, 7, // base 15-21
+      6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, // base 22-35
+      5 // base 36
+    };
+  
+    /**
+     * A table of values radix*maxDigitsForRadix[radix].
+     */
+    private static final int[] maxDigitsRadixPower = new int[37];
+  
+    /**
+     * The largest number of digits (excluding minus sign and leading zeros) that
+     * can fit into a long for a given radix between 2 and 36, inclusive.
+     */
+    private static final int[] maxLengthForRadix = {-1, -1, // unused
+      63, // base 2
+      40, // base 3
+      32, // base 4
+      28, // base 5
+      25, // base 6
+      23, // base 7
+      21, // base 8
+      20, // base 9
+      19, // base 10
+      19, // base 11
+      18, // base 12
+      18, // base 13
+      17, // base 14
+      17, // base 15
+      16, // base 16
+      16, // base 17
+      16, // base 18
+      15, // base 19
+      15, // base 20
+      15, // base 21
+      15, // base 22
+      14, // base 23
+      14, // base 24
+      14, // base 25
+      14, // base 26
+      14, // base 27
+      14, // base 28
+      13, // base 29
+      13, // base 30
+      13, // base 31
+      13, // base 32
+      13, // base 33
+      13, // base 34
+      13, // base 35
+      13  // base 36
+    };
+  
+    /**
+     * A table of floor(MAX_VALUE / maxDigitsRadixPower).
+     */
+    private static final long[] maxValueForRadix = new long[37];
+  
+    static {
+      for (int i = 2; i <= 36; i++) {
+        maxDigitsRadixPower[i] = (int) Math.pow(i, maxDigitsForRadix[i]);
+        maxValueForRadix[i] = Long.MAX_VALUE / maxDigitsRadixPower[i];
+      }
+    }
+  }
+
+  /**
    * @skip
    * 
    * This function will determine the radix that the string is expressed in
@@ -111,7 +194,7 @@
 
     return toReturn;
   }
-
+  
   /**
    * @skip
    * 
@@ -146,7 +229,104 @@
 
     return toReturn;
   }
+  
+  /**
+   * @skip
+   * 
+   * This function contains common logic for parsing a String in a given radix
+   * and validating the result.
+   */
+  protected static long __parseAndValidateLong(String s, int radix)
+      throws NumberFormatException {
+    
+    if (s == null) {
+      throw new NumberFormatException("null");
+    }
+    if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
+      throw new NumberFormatException("radix " + radix + " out of range");
+    }
 
+    int length = s.length();
+    boolean negative = (length > 0) && (s.charAt(0) == '-');
+    if (negative) {
+      s = s.substring(1);
+      length--;
+    }
+    if (length == 0) {
+      throw NumberFormatException.forInputString(s);
+    }
+
+    // Strip leading zeros
+    while (s.length() > 0 && s.charAt(0) == '0') {
+      s = s.substring(1);
+      length--;
+    }
+    
+    // Immediately eject numbers that are too long -- this avoids more complex
+    // overflow handling below
+    if (length > __ParseLong.maxLengthForRadix[radix]) {
+      throw NumberFormatException.forInputString(s);
+    }
+    
+    // Validate the digits
+    int maxNumericDigit = '0' + Math.min(radix, 10);
+    int maxLowerCaseDigit = radix + 'a' - 10;
+    int maxUpperCaseDigit = radix + 'A' - 10;
+    for (int i = 0; i < length; i++) {
+      char c = s.charAt(i);
+      if (c >= '0' && c < maxNumericDigit) {
+        continue;
+      }
+      if (c >= 'a' && c < maxLowerCaseDigit) {
+        continue;
+      }
+      if (c >= 'A' && c < maxUpperCaseDigit) {
+        continue;
+      }
+      throw NumberFormatException.forInputString(s);
+    }
+
+    long toReturn = 0;
+    int maxDigits = __ParseLong.maxDigitsForRadix[radix];
+    long radixPower = __ParseLong.maxDigitsRadixPower[radix];
+    long maxValue = __ParseLong.maxValueForRadix[radix];
+    
+    boolean firstTime = true;
+    int head = length % maxDigits;
+    if (head > 0) {
+      toReturn = __parseInt(s.substring(0, head), radix);
+      s = s.substring(head);
+      length -= head;
+      firstTime = false;
+    }
+    
+    while (length >= maxDigits) {
+      head = __parseInt(s.substring(0, maxDigits), radix);
+      s = s.substring(maxDigits);
+      length -= maxDigits;
+      if (!firstTime) {
+        // Check whether multiplying by radixPower will overflow
+        if (toReturn > maxValue) {
+          throw new NumberFormatException(s);
+        }
+        toReturn *= radixPower;      
+      } else {
+        firstTime = false;
+      }
+      toReturn += head;
+    }
+    
+    // A negative value means we overflowed Long.MAX_VALUE
+    if (toReturn < 0) {
+      throw NumberFormatException.forInputString(s);
+    }
+    
+    if (negative) {
+      toReturn = -toReturn;
+    }
+    return toReturn;
+  }
+  
   /**
    * @skip
    */
diff --git a/user/super/com/google/gwt/emul/java/util/Arrays.java b/user/super/com/google/gwt/emul/java/util/Arrays.java
index 89dcc33..662a202 100644
--- a/user/super/com/google/gwt/emul/java/util/Arrays.java
+++ b/user/super/com/google/gwt/emul/java/util/Arrays.java
@@ -1345,7 +1345,7 @@
    */
   @UnsafeNativeLong
   private static native void nativeLongSort(Object array) /*-{
-    array.sort(@com.google.gwt.lang.LongLib::compare([D[D));
+    array.sort(@com.google.gwt.lang.LongLib::compare(Lcom/google/gwt/lang/LongEmul;Lcom/google/gwt/lang/LongEmul;));
   }-*/;
 
   /**
@@ -1355,7 +1355,7 @@
   private static native void nativeLongSort(Object array, int fromIndex,
       int toIndex) /*-{
     var temp = array.slice(fromIndex, toIndex);
-    temp.sort(@com.google.gwt.lang.LongLib::compare([D[D));
+    temp.sort(@com.google.gwt.lang.LongLib::compare(Lcom/google/gwt/lang/LongEmul;Lcom/google/gwt/lang/LongEmul;));
     var n = toIndex - fromIndex;
     // Do the equivalent of array.splice(fromIndex, n, temp) except
     // flattening the temp slice.
diff --git a/user/test/com/google/gwt/langtest/LongLibGwtTest.java b/user/test/com/google/gwt/langtest/LongLibGwtTest.java
index 66225de..1c6e4b6 100644
--- a/user/test/com/google/gwt/langtest/LongLibGwtTest.java
+++ b/user/test/com/google/gwt/langtest/LongLibGwtTest.java
@@ -15,9 +15,7 @@
  */
 package com.google.gwt.langtest;
 
-import com.google.gwt.core.client.GWT;
 import com.google.gwt.junit.client.GWTTestCase;
-import com.google.gwt.lang.LongLib;
 import com.google.gwt.lang.LongLibTestBase;
 
 /**
@@ -25,12 +23,6 @@
  */
 public class LongLibGwtTest extends GWTTestCase {
 
-  static {
-    if (!GWT.isScript()) {
-      LongLib.RUN_IN_JVM = true;
-    }
-  }
-
   private LongLibTestBase impl = new LongLibTestBase();
 
   @Override
@@ -70,6 +62,10 @@
     impl.testMinMax();
   }
 
+  public void testMod() {
+    impl.testMod();
+  }
+
   public void testMultiplicative() {
     impl.testMultiplicative();
   }
diff --git a/user/test/com/google/gwt/user/client/rpc/TestSetFactory.java b/user/test/com/google/gwt/user/client/rpc/TestSetFactory.java
index 9ae14ed..4831bfd 100644
--- a/user/test/com/google/gwt/user/client/rpc/TestSetFactory.java
+++ b/user/test/com/google/gwt/user/client/rpc/TestSetFactory.java
@@ -493,9 +493,21 @@
   }
 
   public static Long[] createLongArray() {
+    long a = 16123432898849345L;
+    long b = 78234569989880099L;
+    long c = -64289238928934943L;
+    
+    // Create values that are not compile-time constants
+    for (int i = 0; i < 10; i++) {
+      a ^= b;
+      b ^= c;
+      c ^= a;
+    }
+    
     return new Long[] {
         new Long(Long.MAX_VALUE), new Long(Long.MIN_VALUE),
-        new Long(Long.MAX_VALUE), new Long(Long.MIN_VALUE)};
+        new Long(Long.MAX_VALUE), new Long(Long.MIN_VALUE),
+        new Long(a), new Long(b), new Long(c)};
   }
 
   public static LinkedHashMap<String, MarkerTypeLinkedHashMap> createLRULinkedHashMap() {
@@ -541,8 +553,20 @@
   }
 
   public static long[] createPrimitiveLongArray() {
+    long a = 16123432898849345L;
+    long b = 78234569989880099L;
+    long c = -64289238928934943L;
+    
+    // Create values that are not compile-time constants
+    for (int i = 0; i < 10; i++) {
+      a ^= b;
+      b ^= c;
+      c ^= a;
+    }
+    
     return new long[] {
-        Long.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE, Long.MIN_VALUE};
+        Long.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE, Long.MIN_VALUE,
+        a, b, c};
   }
 
   public static short[] createPrimitiveShortArray() {