diff --git a/dictionaries/pt_BR_wordlist.combined.gz b/dictionaries/pt_BR_wordlist.combined.gz
index 19394cb..83dbe79 100644
--- a/dictionaries/pt_BR_wordlist.combined.gz
+++ b/dictionaries/pt_BR_wordlist.combined.gz
Binary files differ
diff --git a/dictionaries/pt_PT_wordlist.combined.gz b/dictionaries/pt_PT_wordlist.combined.gz
index b29e4fd..00d50d0 100644
--- a/dictionaries/pt_PT_wordlist.combined.gz
+++ b/dictionaries/pt_PT_wordlist.combined.gz
Binary files differ
diff --git a/java/res/raw/main_pt_br.dict b/java/res/raw/main_pt_br.dict
index 28db0ed..8c14499 100644
--- a/java/res/raw/main_pt_br.dict
+++ b/java/res/raw/main_pt_br.dict
Binary files differ
diff --git a/java/res/xml/key_styles_common.xml b/java/res/xml/key_styles_common.xml
index 91ebac1..0834adf 100644
--- a/java/res/xml/key_styles_common.xml
+++ b/java/res/xml/key_styles_common.xml
@@ -71,7 +71,7 @@
         >
             <key-style
                 latin:styleName="enterKeyStyle"
-                latin:parentStyle="defaultEnterKeyStyle" />
+                latin:parentStyle="shiftEnterKeyStyle" />
         </case>
         <!-- Smiley in textShortMessage field.
              Overrides common enter key style. -->
diff --git a/java/res/xml/key_styles_enter.xml b/java/res/xml/key_styles_enter.xml
index 3788ca8..61a515b 100644
--- a/java/res/xml/key_styles_enter.xml
+++ b/java/res/xml/key_styles_enter.xml
@@ -99,7 +99,11 @@
         latin:backgroundType="functional"
         latin:parentStyle="navigateMoreKeysStyle" />
     <key-style
-        latin:styleName="defaultActionKeyStyle"
+        latin:styleName="shiftEnterKeyStyle"
+        latin:code="!code/key_shift_enter"
+        latin:parentStyle="defaultEnterKeyStyle" />
+    <key-style
+        latin:styleName="defaultActionEnterKeyStyle"
         latin:code="!code/key_action_enter"
         latin:keyIcon="!icon/undefined"
         latin:backgroundType="action"
@@ -112,7 +116,7 @@
         >
             <key-style
                 latin:styleName="enterKeyStyle"
-                latin:parentStyle="defaultEnterKeyStyle" />
+                latin:parentStyle="shiftEnterKeyStyle" />
         </case>
         <case
             latin:imeAction="actionGo"
@@ -120,7 +124,7 @@
             <key-style
                 latin:styleName="enterKeyStyle"
                 latin:keyLabel="!text/label_go_key"
-                latin:parentStyle="defaultActionKeyStyle" />
+                latin:parentStyle="defaultActionEnterKeyStyle" />
         </case>
         <case
             latin:imeAction="actionNext"
@@ -128,7 +132,7 @@
             <key-style
                 latin:styleName="enterKeyStyle"
                 latin:keyLabel="!text/label_next_key"
-                latin:parentStyle="defaultActionKeyStyle" />
+                latin:parentStyle="defaultActionEnterKeyStyle" />
         </case>
         <case
             latin:imeAction="actionPrevious"
@@ -136,7 +140,7 @@
             <key-style
                 latin:styleName="enterKeyStyle"
                 latin:keyLabel="!text/label_previous_key"
-                latin:parentStyle="defaultActionKeyStyle" />
+                latin:parentStyle="defaultActionEnterKeyStyle" />
         </case>
         <case
             latin:imeAction="actionDone"
@@ -144,7 +148,7 @@
             <key-style
                 latin:styleName="enterKeyStyle"
                 latin:keyLabel="!text/label_done_key"
-                latin:parentStyle="defaultActionKeyStyle" />
+                latin:parentStyle="defaultActionEnterKeyStyle" />
         </case>
         <case
             latin:imeAction="actionSend"
@@ -152,7 +156,7 @@
             <key-style
                 latin:styleName="enterKeyStyle"
                 latin:keyLabel="!text/label_send_key"
-                latin:parentStyle="defaultActionKeyStyle" />
+                latin:parentStyle="defaultActionEnterKeyStyle" />
         </case>
         <case
             latin:imeAction="actionSearch"
@@ -160,7 +164,7 @@
             <key-style
                 latin:styleName="enterKeyStyle"
                 latin:keyIcon="!icon/search_key"
-                latin:parentStyle="defaultActionKeyStyle" />
+                latin:parentStyle="defaultActionEnterKeyStyle" />
         </case>
         <case
             latin:imeAction="actionCustomLabel"
@@ -168,7 +172,7 @@
             <key-style
                 latin:styleName="enterKeyStyle"
                 latin:keyLabelFlags="fromCustomActionLabel"
-                latin:parentStyle="defaultActionKeyStyle" />
+                latin:parentStyle="defaultActionEnterKeyStyle" />
         </case>
         <!-- imeAction is either actionNone or actionUnspecified. -->
         <default>
diff --git a/java/res/xml/spellchecker.xml b/java/res/xml/spellchecker.xml
index 66cd662..813319c 100644
--- a/java/res/xml/spellchecker.xml
+++ b/java/res/xml/spellchecker.xml
@@ -57,18 +57,6 @@
     />
     <subtype
             android:label="@string/subtype_generic"
-            android:subtypeLocale="cs"
-    />
-    <subtype
-            android:label="@string/subtype_generic"
-            android:subtypeLocale="nl"
-    />
-    <subtype
-            android:label="@string/subtype_generic"
-            android:subtypeLocale="hr"
-    />
-    <subtype
-            android:label="@string/subtype_generic"
             android:subtypeLocale="pt_BR"
     />
 </spell-checker>
diff --git a/java/src/com/android/inputmethod/accessibility/KeyCodeDescriptionMapper.java b/java/src/com/android/inputmethod/accessibility/KeyCodeDescriptionMapper.java
index 6a01b01..ea86d98 100644
--- a/java/src/com/android/inputmethod/accessibility/KeyCodeDescriptionMapper.java
+++ b/java/src/com/android/inputmethod/accessibility/KeyCodeDescriptionMapper.java
@@ -209,7 +209,7 @@
     private String getDescriptionForActionKey(final Context context, final Keyboard keyboard,
             final Key key) {
         final KeyboardId keyboardId = keyboard.mId;
-        final int actionId = keyboardId.imeActionId();
+        final int actionId = keyboardId.imeAction();
         final int resId;
 
         // Always use the label, if available.
diff --git a/java/src/com/android/inputmethod/event/Combiner.java b/java/src/com/android/inputmethod/event/Combiner.java
new file mode 100644
index 0000000..ab6b70c
--- /dev/null
+++ b/java/src/com/android/inputmethod/event/Combiner.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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.android.inputmethod.event;
+
+/**
+ * A generic interface for combiners.
+ */
+public interface Combiner {
+    /**
+     * Combine an event with the existing state and return the new event.
+     * @param event the event to combine with the existing state.
+     * @return the resulting event.
+     */
+    Event combine(Event event);
+}
diff --git a/java/src/com/android/inputmethod/event/DeadKeyCombiner.java b/java/src/com/android/inputmethod/event/DeadKeyCombiner.java
new file mode 100644
index 0000000..52987d5
--- /dev/null
+++ b/java/src/com/android/inputmethod/event/DeadKeyCombiner.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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.android.inputmethod.event;
+
+import android.text.TextUtils;
+import android.view.KeyCharacterMap;
+
+import com.android.inputmethod.latin.Constants;
+
+/**
+ * A combiner that handles dead keys.
+ */
+public class DeadKeyCombiner implements Combiner {
+    final StringBuilder mDeadSequence = new StringBuilder();
+
+    @Override
+    public Event combine(final Event event) {
+        if (null == event) return null; // Just in case some combiner is broken
+        if (TextUtils.isEmpty(mDeadSequence)) {
+            if (event.isDead()) {
+                mDeadSequence.appendCodePoint(event.mCodePoint);
+            }
+            return event;
+        } else {
+            // TODO: Allow combining for several dead chars rather than only the first one.
+            // The framework doesn't know how to do this now.
+            final int deadCodePoint = mDeadSequence.codePointAt(0);
+            mDeadSequence.setLength(0);
+            final int resultingCodePoint =
+                    KeyCharacterMap.getDeadChar(deadCodePoint, event.mCodePoint);
+            if (0 == resultingCodePoint) {
+                // We can't combine both characters. We need to commit the dead key as a committable
+                // character, and the next char too unless it's a space (because as a special case,
+                // dead key + space should result in only the dead key being committed - that's
+                // how dead keys work).
+                // If the event is a space, we should commit the dead char alone, but if it's
+                // not, we need to commit both.
+                return Event.createCommittableEvent(deadCodePoint,
+                        Constants.CODE_SPACE == event.mCodePoint ? null : event /* next */);
+            } else {
+                // We could combine the characters.
+                return Event.createCommittableEvent(resultingCodePoint, null /* next */);
+            }
+        }
+    }
+
+}
diff --git a/java/src/com/android/inputmethod/event/Event.java b/java/src/com/android/inputmethod/event/Event.java
index 3fe5d5b..1f3320e 100644
--- a/java/src/com/android/inputmethod/event/Event.java
+++ b/java/src/com/android/inputmethod/event/Event.java
@@ -61,26 +61,33 @@
     // ctrl, there is no code point associated so this should be NOT_A_CODE_POINT to avoid
     // unintentional use of its value when it's not relevant.
     final public int mCodePoint;
+    // The next event, if any. Null if there is no next event yet.
+    final public Event mNextEvent;
 
     // This method is private - to create a new event, use one of the create* utility methods.
-    private Event(final int type, final int codePoint) {
+    private Event(final int type, final int codePoint, final Event next) {
         mType = type;
         mCodePoint = codePoint;
+        mNextEvent = next;
     }
 
-    public static Event createDeadEvent(final int codePoint) {
-        return new Event(EVENT_DEAD, codePoint);
+    public static Event createDeadEvent(final int codePoint, final Event next) {
+        return new Event(EVENT_DEAD, codePoint, next);
     }
 
-    public static Event createCommittableEvent(final int codePoint) {
-        return new Event(EVENT_COMMITTABLE, codePoint);
+    public static Event createCommittableEvent(final int codePoint, final Event next) {
+        return new Event(EVENT_COMMITTABLE, codePoint, next);
     }
 
     public static Event createNotHandledEvent() {
-        return new Event(EVENT_NOT_HANDLED, NOT_A_CODE_POINT);
+        return new Event(EVENT_NOT_HANDLED, NOT_A_CODE_POINT, null);
     }
 
     public boolean isCommittable() {
         return EVENT_COMMITTABLE == mType;
     }
+
+    public boolean isDead() {
+        return EVENT_DEAD == mType;
+    }
 }
diff --git a/java/src/com/android/inputmethod/event/EventInterpreter.java b/java/src/com/android/inputmethod/event/EventInterpreter.java
index f918578..6efe899 100644
--- a/java/src/com/android/inputmethod/event/EventInterpreter.java
+++ b/java/src/com/android/inputmethod/event/EventInterpreter.java
@@ -19,9 +19,12 @@
 import android.util.SparseArray;
 import android.view.KeyEvent;
 
+import com.android.inputmethod.latin.CollectionUtils;
 import com.android.inputmethod.latin.Constants;
 import com.android.inputmethod.latin.LatinIME;
 
+import java.util.ArrayList;
+
 /**
  * This class implements the logic between receiving events and generating code points.
  *
@@ -40,6 +43,7 @@
     final SparseArray<HardwareEventDecoder> mHardwareEventDecoders;
     final SoftwareEventDecoder mSoftwareEventDecoder;
     final LatinIME mLatinIme;
+    final ArrayList<Combiner> mCombiners;
 
     /**
      * Create a default interpreter.
@@ -74,6 +78,8 @@
         // capacity of 1.
         mHardwareEventDecoders = new SparseArray<HardwareEventDecoder>(1);
         mSoftwareEventDecoder = new SoftwareKeyboardEventDecoder();
+        mCombiners = CollectionUtils.newArrayList();
+        mCombiners.add(new DeadKeyCombiner());
         mLatinIme = latinIme;
     }
 
@@ -106,19 +112,22 @@
     }
 
     private boolean onEvent(final Event event) {
-        if (event.isCommittable()) {
-            mLatinIme.onCodeInput(event.mCodePoint,
-                    Constants.EXTERNAL_KEYBOARD_COORDINATE, Constants.EXTERNAL_KEYBOARD_COORDINATE);
-            return true;
+        Event currentlyProcessingEvent = event;
+        boolean processed = false;
+        for (int i = 0; i < mCombiners.size(); ++i) {
+            currentlyProcessingEvent = mCombiners.get(i).combine(event);
         }
-        // TODO: Classify the event - input or non-input (see design doc)
-        // TODO: IF action event
-        //          Send decoded action back to LatinIME
-        //       ELSE
-        //          Send input event to the combiner
-        //          Get back new input material + visual feedback + combiner state
-        //          Route the event to Latin IME
-        //       ENDIF
-        return false;
+        while (null != currentlyProcessingEvent) {
+            if (currentlyProcessingEvent.isCommittable()) {
+                mLatinIme.onCodeInput(currentlyProcessingEvent.mCodePoint,
+                        Constants.EXTERNAL_KEYBOARD_COORDINATE,
+                        Constants.EXTERNAL_KEYBOARD_COORDINATE);
+                processed = true;
+            } else if (event.isDead()) {
+                processed = true;
+            }
+            currentlyProcessingEvent = currentlyProcessingEvent.mNextEvent;
+        }
+        return processed;
     }
 }
diff --git a/java/src/com/android/inputmethod/event/HardwareKeyboardEventDecoder.java b/java/src/com/android/inputmethod/event/HardwareKeyboardEventDecoder.java
index 554319e..2fb7fe8 100644
--- a/java/src/com/android/inputmethod/event/HardwareKeyboardEventDecoder.java
+++ b/java/src/com/android/inputmethod/event/HardwareKeyboardEventDecoder.java
@@ -47,17 +47,18 @@
         // the key for 'A' or Space, but also Backspace or Ctrl or Caps Lock.
         final int keyCode = keyEvent.getKeyCode();
         if (KeyEvent.KEYCODE_DEL == keyCode) {
-            return Event.createCommittableEvent(Constants.CODE_DELETE);
+            return Event.createCommittableEvent(Constants.CODE_DELETE, null /* next */);
         }
         if (keyEvent.isPrintingKey() || KeyEvent.KEYCODE_SPACE == keyCode
                 || KeyEvent.KEYCODE_ENTER == keyCode) {
             if (0 != (codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT)) {
                 // A dead key.
-                return Event.createDeadEvent(codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT_MASK);
+                return Event.createDeadEvent(
+                        codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT_MASK, null /* next */);
             } else {
                 // A committable character. This should be committed right away, taking into
                 // account the current state.
-                return Event.createCommittableEvent(codePointAndFlags);
+                return Event.createCommittableEvent(codePointAndFlags, null /* next */);
             }
         } else {
             return Event.createNotHandledEvent();
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardId.java b/java/src/com/android/inputmethod/keyboard/KeyboardId.java
index b413615..02116ca 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardId.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardId.java
@@ -59,8 +59,6 @@
     public static final int FORM_FACTOR_TABLET7 = 1;
     public static final int FORM_FACTOR_TABLET10 = 2;
 
-    private static final int IME_ACTION_CUSTOM_LABEL = EditorInfo.IME_MASK_ACTION + 1;
-
     public final InputMethodSubtype mSubtype;
     public final Locale mLocale;
     public final int mDeviceFormFactor;
@@ -174,19 +172,7 @@
     }
 
     public int imeAction() {
-        final int actionId = mEditorInfo.imeOptions & EditorInfo.IME_MASK_ACTION;
-        if ((mEditorInfo.imeOptions & EditorInfo.IME_FLAG_NO_ENTER_ACTION) != 0) {
-            return EditorInfo.IME_ACTION_NONE;
-        } else if (mEditorInfo.actionLabel != null) {
-            return IME_ACTION_CUSTOM_LABEL;
-        } else {
-            return actionId;
-        }
-    }
-
-    public int imeActionId() {
-        final int actionId = imeAction();
-        return actionId == IME_ACTION_CUSTOM_LABEL ? mEditorInfo.actionId : actionId;
+        return InputTypeUtils.getImeOptionsActionIdFromEditorInfo(mEditorInfo);
     }
 
     @Override
@@ -269,7 +255,7 @@
     }
 
     public static String actionName(final int actionId) {
-        return (actionId == IME_ACTION_CUSTOM_LABEL) ? "actionCustomLabel"
+        return (actionId == InputTypeUtils.IME_ACTION_CUSTOM_LABEL) ? "actionCustomLabel"
                 : EditorInfoCompatUtils.imeActionName(actionId);
     }
 }
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardView.java b/java/src/com/android/inputmethod/keyboard/KeyboardView.java
index 63b9ed6..b7584d4 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardView.java
@@ -153,6 +153,10 @@
     private boolean mShowKeyPreviewPopup = true;
     private int mKeyPreviewLingerTimeout;
 
+    // Gesture floating preview text
+    // TODO: Make this parameter customizable by user via settings.
+    private int mGestureFloatingPreviewTextLingerTimeout;
+
     // Background state set
     private static final int[][][] KEY_PREVIEW_BACKGROUND_STATE_TABLE = {
         { // STATE_MIDDLE
@@ -204,6 +208,7 @@
 
     public static class DrawingHandler extends StaticInnerHandlerWrapper<KeyboardView> {
         private static final int MSG_DISMISS_KEY_PREVIEW = 0;
+        private static final int MSG_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT = 1;
 
         public DrawingHandler(final KeyboardView outerInstance) {
             super(outerInstance);
@@ -221,6 +226,9 @@
                     previewText.setVisibility(INVISIBLE);
                 }
                 break;
+            case MSG_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT:
+                keyboardView.mPreviewPlacerView.setGestureFloatingPreviewText(SuggestedWords.EMPTY);
+                break;
             }
         }
 
@@ -236,6 +244,10 @@
             removeMessages(MSG_DISMISS_KEY_PREVIEW);
         }
 
+        public void dismissGestureFloatingPreviewText(final long delay) {
+            sendMessageDelayed(obtainMessage(MSG_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT), delay);
+        }
+
         public void cancelAllMessages() {
             cancelAllDismissKeyPreviews();
         }
@@ -279,6 +291,8 @@
                 R.styleable.KeyboardView_moreKeysLayout, 0);
         mBackgroundDimAlpha = keyboardViewAttr.getInt(
                 R.styleable.KeyboardView_backgroundDimAlpha, 0);
+        mGestureFloatingPreviewTextLingerTimeout = keyboardViewAttr.getInt(
+                R.styleable.KeyboardView_gestureFloatingPreviewTextLingerTimeout, 0);
         keyboardViewAttr.recycle();
 
         final TypedArray keyAttr = context.obtainStyledAttributes(attrs,
@@ -877,7 +891,7 @@
 
     public void dismissGestureFloatingPreviewText() {
         locatePreviewPlacerView();
-        mPreviewPlacerView.dismissGestureFloatingPreviewText();
+        mDrawingHandler.dismissGestureFloatingPreviewText(mGestureFloatingPreviewTextLingerTimeout);
     }
 
     @Override
diff --git a/java/src/com/android/inputmethod/keyboard/PointerTracker.java b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
index 62e674a..036372c 100644
--- a/java/src/com/android/inputmethod/keyboard/PointerTracker.java
+++ b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
@@ -920,8 +920,12 @@
             final boolean isMajorEvent, final Key key) {
         final int gestureTime = (int)(eventTime - sGestureFirstDownTime);
         if (mIsDetectingGesture) {
+            final int beforeLength = mGestureStrokeWithPreviewPoints.getLength();
             final boolean onValidArea = mGestureStrokeWithPreviewPoints.addPointOnKeyboard(
                     x, y, gestureTime, isMajorEvent);
+            if (mGestureStrokeWithPreviewPoints.getLength() > beforeLength) {
+                mTimerProxy.startUpdateBatchInputTimer(this);
+            }
             // If the move event goes out from valid batch input area, cancel batch input.
             if (!onValidArea) {
                 cancelBatchInput();
@@ -943,7 +947,6 @@
         if (DEBUG_MOVE_EVENT) {
             printTouchEvent("onMoveEvent:", x, y, eventTime);
         }
-        mTimerProxy.cancelUpdateBatchInputTimer(this);
         if (mIsTrackingCanceled) {
             return;
         }
diff --git a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java
index b5ba98d..0fdbb0d 100644
--- a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java
+++ b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java
@@ -80,17 +80,17 @@
         mNativeProximityInfo = createNativeProximityInfo(touchPositionCorrection);
     }
 
-    public static ProximityInfo createDummyProximityInfo() {
+    private static ProximityInfo createDummyProximityInfo() {
         return new ProximityInfo("", 1, 1, 1, 1, 1, 1, EMPTY_KEY_ARRAY, null);
     }
 
-    public static ProximityInfo createSpellCheckerProximityInfo(final int[] proximity,
+    public static ProximityInfo createSpellCheckerProximityInfo(final int[] proximityCharsArray,
             final int rowSize, final int gridWidth, final int gridHeight) {
         final ProximityInfo spellCheckerProximityInfo = createDummyProximityInfo();
         spellCheckerProximityInfo.mNativeProximityInfo =
                 spellCheckerProximityInfo.setProximityInfoNative("",
                         rowSize, gridWidth, gridHeight, gridWidth, gridHeight,
-                        1, proximity, 0, null, null, null, null, null, null, null, null);
+                        1, proximityCharsArray, 0, null, null, null, null, null, null, null, null);
         return spellCheckerProximityInfo;
     }
 
@@ -100,15 +100,13 @@
     }
 
     // TODO: Stop passing proximityCharsArray
-    private native long setProximityInfoNative(
-            String locale, int maxProximityCharsSize, int displayWidth,
-            int displayHeight, int gridWidth, int gridHeight,
-            int mostCommonKeyWidth, int[] proximityCharsArray,
-            int keyCount, int[] keyXCoordinates, int[] keyYCoordinates,
-            int[] keyWidths, int[] keyHeights, int[] keyCharCodes,
+    private static native long setProximityInfoNative(String locale, int maxProximityCharsSize,
+            int displayWidth, int displayHeight, int gridWidth, int gridHeight,
+            int mostCommonKeyWidth, int[] proximityCharsArray, int keyCount, int[] keyXCoordinates,
+            int[] keyYCoordinates, int[] keyWidths, int[] keyHeights, int[] keyCharCodes,
             float[] sweetSpotCenterX, float[] sweetSpotCenterY, float[] sweetSpotRadii);
 
-    private native void releaseProximityInfoNative(long nativeProximityInfo);
+    private static native void releaseProximityInfoNative(long nativeProximityInfo);
 
     private static boolean needsProximityInfo(final Key key) {
         // Don't include special keys into ProximityInfo.
@@ -232,10 +230,10 @@
         }
 
         // TODO: Stop passing proximityCharsArray
-        return setProximityInfoNative(mLocaleStr, MAX_PROXIMITY_CHARS_SIZE,
-                mKeyboardMinWidth, mKeyboardHeight, mGridWidth, mGridHeight, mMostCommonKeyWidth,
-                proximityCharsArray, keyCount, keyXCoordinates, keyYCoordinates, keyWidths,
-                keyHeights, keyCharCodes, sweetSpotCenterXs, sweetSpotCenterYs, sweetSpotRadii);
+        return setProximityInfoNative(mLocaleStr, MAX_PROXIMITY_CHARS_SIZE, mKeyboardMinWidth,
+                mKeyboardHeight, mGridWidth, mGridHeight, mMostCommonKeyWidth, proximityCharsArray,
+                keyCount, keyXCoordinates, keyYCoordinates, keyWidths, keyHeights, keyCharCodes,
+                sweetSpotCenterXs, sweetSpotCenterYs, sweetSpotRadii);
     }
 
     public long getNativeProximityInfo() {
diff --git a/java/src/com/android/inputmethod/keyboard/internal/GestureFloatingPreviewText.java b/java/src/com/android/inputmethod/keyboard/internal/GestureFloatingPreviewText.java
index 30ca859..aed23a4 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/GestureFloatingPreviewText.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/GestureFloatingPreviewText.java
@@ -100,11 +100,7 @@
     }
 
     public void setSuggetedWords(final SuggestedWords suggestedWords) {
-        if (suggestedWords == null) {
-            mSuggestedWords = SuggestedWords.EMPTY;
-        } else {
-            mSuggestedWords = suggestedWords;
-        }
+        mSuggestedWords = suggestedWords;
         updatePreviewPosition();
     }
 
diff --git a/java/src/com/android/inputmethod/keyboard/internal/GesturePreviewTrail.java b/java/src/com/android/inputmethod/keyboard/internal/GesturePreviewTrail.java
index f8949b2..4a8407c 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/GesturePreviewTrail.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/GesturePreviewTrail.java
@@ -133,10 +133,12 @@
     private static float getWidth(final int elapsedTime, final Params params) {
         final int deltaTime = params.mTrailLingerDuration - elapsedTime;
         final float deltaWidth = params.mTrailStartWidth - params.mTrailEndWidth;
-        return (deltaTime * deltaWidth) / params.mTrailLingerDuration + params.mTrailEndWidth;
+        return Math.max(
+                (deltaTime * deltaWidth) / params.mTrailLingerDuration, params.mTrailEndWidth);
     }
 
     private final RoundedLine mRoundedLine = new RoundedLine();
+    private final Rect mRoundedLineBounds = new Rect();
 
     /**
      * Draw gesture preview trail
@@ -148,6 +150,8 @@
      */
     public boolean drawGestureTrail(final Canvas canvas, final Paint paint,
             final Rect outBoundsRect, final Params params) {
+        // Initialize bounds rectangle.
+        outBoundsRect.setEmpty();
         final int trailSize = mEventTimes.getLength();
         if (trailSize == 0) {
             return false;
@@ -170,39 +174,32 @@
         if (startIndex < trailSize) {
             paint.setColor(params.mTrailColor);
             paint.setStyle(Paint.Style.FILL);
-            final RoundedLine line = mRoundedLine;
+            final RoundedLine roundedLine = mRoundedLine;
             int p1x = getXCoordValue(xCoords[startIndex]);
             int p1y = yCoords[startIndex];
             final int lastTime = sinceDown - eventTimes[startIndex];
-            float maxWidth = getWidth(lastTime, params);
-            float r1 = maxWidth / 2.0f;
-            // Initialize bounds rectangle.
-            outBoundsRect.set(p1x, p1y, p1x, p1y);
+            float r1 = getWidth(lastTime, params) / 2.0f;
             for (int i = startIndex + 1; i < trailSize; i++) {
                 final int elapsedTime = sinceDown - eventTimes[i];
                 final int p2x = getXCoordValue(xCoords[i]);
                 final int p2y = yCoords[i];
-                final float width = getWidth(elapsedTime, params);
-                final float r2 = width / 2.0f;
+                final float r2 = getWidth(elapsedTime, params) / 2.0f;
                 // Draw trail line only when the current point isn't a down point.
                 if (!isDownEventXCoord(xCoords[i])) {
-                    final Path path = line.makePath(p1x, p1y, r1, p2x, p2y, r2);
+                    final Path path = roundedLine.makePath(p1x, p1y, r1, p2x, p2y, r2);
                     if (path != null) {
                         final int alpha = getAlpha(elapsedTime, params);
                         paint.setAlpha(alpha);
                         canvas.drawPath(path, paint);
                         // Take union for the bounds.
-                        outBoundsRect.union(p2x, p2y);
-                        maxWidth = Math.max(maxWidth, width);
+                        roundedLine.getBounds(mRoundedLineBounds);
+                        outBoundsRect.union(mRoundedLineBounds);
                     }
                 }
                 p1x = p2x;
                 p1y = p2y;
                 r1 = r2;
             }
-            // Take care of trail line width.
-            final int inset = -((int)maxWidth + 1);
-            outBoundsRect.inset(inset, inset);
         }
 
         final int newSize = trailSize - startIndex;
diff --git a/java/src/com/android/inputmethod/keyboard/internal/GestureStroke.java b/java/src/com/android/inputmethod/keyboard/internal/GestureStroke.java
index adf2236..ea03f1b 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/GestureStroke.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/GestureStroke.java
@@ -163,6 +163,10 @@
         }
     }
 
+    public int getLength() {
+        return mEventTimes.getLength();
+    }
+
     public void onDownEvent(final int x, final int y, final long downTime,
             final long gestureFirstDownTime, final long lastTypingTime) {
         reset();
@@ -202,7 +206,7 @@
         if (!hasDetectedFastMove()) {
             return false;
         }
-        final int size = mEventTimes.getLength();
+        final int size = getLength();
         if (size <= 0) {
             return false;
         }
@@ -229,7 +233,7 @@
     }
 
     public void duplicateLastPointWith(final int time) {
-        final int lastIndex = mEventTimes.getLength() - 1;
+        final int lastIndex = getLength() - 1;
         if (lastIndex >= 0) {
             final int x = mXCoordinates.get(lastIndex);
             final int y = mYCoordinates.get(lastIndex);
@@ -255,7 +259,7 @@
     }
 
     private void appendPoint(final int x, final int y, final int time) {
-        final int lastIndex = mEventTimes.getLength() - 1;
+        final int lastIndex = getLength() - 1;
         // The point that is created by {@link duplicateLastPointWith(int)} may have later event
         // time than the next {@link MotionEvent}. To maintain the monotonicity of the event time,
         // drop the successive point here.
@@ -281,7 +285,7 @@
     }
 
     private int detectFastMove(final int x, final int y, final int time) {
-        final int size = mEventTimes.getLength();
+        final int size = getLength();
         final int lastIndex = size - 1;
         final int lastX = mXCoordinates.get(lastIndex);
         final int lastY = mYCoordinates.get(lastIndex);
@@ -321,7 +325,7 @@
      */
     public boolean addPointOnKeyboard(final int x, final int y, final int time,
             final boolean isMajorEvent) {
-        final int size = mEventTimes.getLength();
+        final int size = getLength();
         if (size <= 0) {
             // Down event
             appendPoint(x, y, time);
@@ -348,7 +352,7 @@
         final int pixelsPerSec = pixels * MSEC_PER_SEC;
         // Equivalent to (pixels / msecs < mGestureRecognitionThreshold / MSEC_PER_SEC)
         if (pixelsPerSec < mGestureRecognitionSpeedThreshold * msecs) {
-            mIncrementalRecognitionSize = mEventTimes.getLength();
+            mIncrementalRecognitionSize = getLength();
         }
     }
 
@@ -358,7 +362,7 @@
     }
 
     public final void appendAllBatchPoints(final InputPointers out) {
-        appendBatchPoints(out, mEventTimes.getLength());
+        appendBatchPoints(out, getLength());
     }
 
     public final void appendIncrementalBatchPoints(final InputPointers out) {
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyboardCodesSet.java b/java/src/com/android/inputmethod/keyboard/internal/KeyboardCodesSet.java
index 428e31c..0d852dd 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeyboardCodesSet.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeyboardCodesSet.java
@@ -51,6 +51,7 @@
         "key_action_enter",
         "key_action_next",
         "key_action_previous",
+        "key_shift_enter",
         "key_language_switch",
         "key_research",
         "key_unspecified",
@@ -86,6 +87,7 @@
         Constants.CODE_ACTION_ENTER,
         Constants.CODE_ACTION_NEXT,
         Constants.CODE_ACTION_PREVIOUS,
+        Constants.CODE_SHIFT_ENTER,
         Constants.CODE_LANGUAGE_SWITCH,
         Constants.CODE_RESEARCH,
         Constants.CODE_UNSPECIFIED,
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyboardTextsSet.java b/java/src/com/android/inputmethod/keyboard/internal/KeyboardTextsSet.java
index 6fefb80..6ad7f9b 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeyboardTextsSet.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeyboardTextsSet.java
@@ -528,7 +528,7 @@
         // U+064E: "َ" ARABIC FATHA
         // U+0640: "ـ" ARABIC TATWEEL
         // In order to make Tatweel easily distinguishable from other punctuations, we use consecutive Tatweels only for its displayed label.
-        /* 57 */ "!fixedColumnOrder!7,\u0655,\u0654,\u0652,\u064D,\u064C,\u064B,\u0651,\u0656,\u0670,\u0653,\u0650,\u064F,\u064E,\u0640\u0640\u0640|\u0640",
+        /* 57 */ "!fixedColumnOrder!7, \u0655|\u0655, \u0654|\u0654, \u0652|\u0652, \u064D|\u064D, \u064C|\u064C, \u064B|\u064B, \u0651|\u0651, \u0656|\u0656, \u0670|\u0670, \u0653|\u0653, \u0650|\u0650, \u064F|\u064F, \u064E|\u064E,\u0640\u0640\u0640|\u0640",
         /* 58 */ "\u0651",
         // U+0661: "١" ARABIC-INDIC DIGIT ONE
         /* 59 */ "\u0661",
@@ -1327,7 +1327,7 @@
         // U+064E: "َ" ARABIC FATHA
         // U+0640: "ـ" ARABIC TATWEEL
         // In order to make Tatweel easily distinguishable from other punctuations, we use consecutive Tatweels only for its displayed label.
-        /* 57 */ "!fixedColumnOrder!7,\u0655,\u0652,\u0651,\u064C,\u064D,\u064B,\u0654,\u0656,\u0670,\u0653,\u064F,\u0650,\u064E,\u0640\u0640\u0640|\u0640",
+        /* 57 */ "!fixedColumnOrder!7, \u0655|\u0655, \u0652|\u0652, \u0651|\u0651, \u064C|\u064C, \u064D|\u064D, \u064B|\u064B, \u0654|\u0654, \u0656|\u0656, \u0670|\u0670, \u0653|\u0653, \u064F|\u064F, \u0650|\u0650, \u064E|\u064E,\u0640\u0640\u0640|\u0640",
         /* 58 */ "\u064B",
         // U+06F1: "۱" EXTENDED ARABIC-INDIC DIGIT ONE
         /* 59 */ "\u06F1",
diff --git a/java/src/com/android/inputmethod/keyboard/internal/PreviewPlacerView.java b/java/src/com/android/inputmethod/keyboard/internal/PreviewPlacerView.java
index a005dc9..7c87467 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/PreviewPlacerView.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/PreviewPlacerView.java
@@ -41,6 +41,7 @@
 public final class PreviewPlacerView extends RelativeLayout {
     private final int[] mKeyboardViewOrigin = CoordinateUtils.newInstance();
 
+    // TODO: Consolidate gesture preview trail with {@link KeyboardView}
     private final SparseArray<GesturePreviewTrail> mGesturePreviewTrails =
             CollectionUtils.newSparseArray();
     private final Params mGesturePreviewTrailParams;
@@ -51,7 +52,8 @@
     private int mOffscreenOffsetY;
     private Bitmap mOffscreenBuffer;
     private final Canvas mOffscreenCanvas = new Canvas();
-    private final Rect mOffscreenDirtyRect = new Rect();
+    private final Rect mOffscreenSrcRect = new Rect();
+    private final Rect mDirtyRect = new Rect();
     private final Rect mGesturePreviewTrailBoundsRect = new Rect(); // per trail
     private final GestureFloatingPreviewText mGestureFloatingPreviewText;
     private boolean mShowSlidingKeyInputPreview;
@@ -60,19 +62,16 @@
 
     private final DrawingHandler mDrawingHandler;
 
+    // TODO: Remove drawing handler.
     private static final class DrawingHandler extends StaticInnerHandlerWrapper<PreviewPlacerView> {
-        private static final int MSG_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT = 0;
-        private static final int MSG_UPDATE_GESTURE_PREVIEW_TRAIL = 1;
+        private static final int MSG_UPDATE_GESTURE_PREVIEW_TRAIL = 0;
 
         private final Params mGesturePreviewTrailParams;
-        private final int mGestureFloatingPreviewTextLingerTimeout;
 
         public DrawingHandler(final PreviewPlacerView outerInstance,
-                final Params gesturePreviewTrailParams,
-                final int getstureFloatinPreviewTextLinerTimeout) {
+                final Params gesturePreviewTrailParams) {
             super(outerInstance);
             mGesturePreviewTrailParams = gesturePreviewTrailParams;
-            mGestureFloatingPreviewTextLingerTimeout = getstureFloatinPreviewTextLinerTimeout;
         }
 
         @Override
@@ -80,21 +79,12 @@
             final PreviewPlacerView placerView = getOuterInstance();
             if (placerView == null) return;
             switch (msg.what) {
-            case MSG_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT:
-                placerView.setGestureFloatingPreviewText(null);
-                break;
             case MSG_UPDATE_GESTURE_PREVIEW_TRAIL:
                 placerView.invalidate();
                 break;
             }
         }
 
-        public void dismissGestureFloatingPreviewText() {
-            removeMessages(MSG_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT);
-            sendMessageDelayed(obtainMessage(MSG_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT),
-                    mGestureFloatingPreviewTextLingerTimeout);
-        }
-
         public void postUpdateGestureTrailPreview() {
             removeMessages(MSG_UPDATE_GESTURE_PREVIEW_TRAIL);
             sendMessageDelayed(obtainMessage(MSG_UPDATE_GESTURE_PREVIEW_TRAIL),
@@ -112,16 +102,13 @@
 
         final TypedArray keyboardViewAttr = context.obtainStyledAttributes(
                 attrs, R.styleable.KeyboardView, defStyle, R.style.KeyboardView);
-        final int gestureFloatingPreviewTextLingerTimeout = keyboardViewAttr.getInt(
-                R.styleable.KeyboardView_gestureFloatingPreviewTextLingerTimeout, 0);
         // TODO: mGestureFloatingPreviewText could be an instance of GestureFloatingPreviewText or
         // MultiGesturePreviewText, depending on the user's choice in the settings.
         mGestureFloatingPreviewText = new GestureFloatingPreviewText(keyboardViewAttr, context);
         mGesturePreviewTrailParams = new Params(keyboardViewAttr);
         keyboardViewAttr.recycle();
 
-        mDrawingHandler = new DrawingHandler(this, mGesturePreviewTrailParams,
-                gestureFloatingPreviewTextLingerTimeout);
+        mDrawingHandler = new DrawingHandler(this, mGesturePreviewTrailParams);
 
         final Paint gesturePaint = new Paint();
         gesturePaint.setAntiAlias(true);
@@ -207,6 +194,7 @@
         mOffscreenBuffer = Bitmap.createBitmap(
                 mOffscreenWidth, mOffscreenHeight, Bitmap.Config.ARGB_8888);
         mOffscreenCanvas.setBitmap(mOffscreenBuffer);
+        mOffscreenCanvas.translate(0, mOffscreenOffsetY);
     }
 
     @Override
@@ -219,19 +207,18 @@
             mayAllocateOffscreenBuffer();
             // Draw gesture trails to offscreen buffer.
             final boolean needsUpdatingGesturePreviewTrail = drawGestureTrails(
-                    mOffscreenCanvas, mGesturePaint, mOffscreenDirtyRect);
-            // Transfer offscreen buffer to screen.
-            if (!mOffscreenDirtyRect.isEmpty()) {
-                canvas.translate(0, - mOffscreenOffsetY);
-                canvas.drawBitmap(mOffscreenBuffer, mOffscreenDirtyRect, mOffscreenDirtyRect,
-                        mGesturePaint);
-                canvas.translate(0, mOffscreenOffsetY);
-                // Note: Defer clearing the dirty rectangle here because we will get cleared
-                // rectangle on the canvas.
-            }
+                    mOffscreenCanvas, mGesturePaint, mDirtyRect);
             if (needsUpdatingGesturePreviewTrail) {
                 mDrawingHandler.postUpdateGestureTrailPreview();
             }
+            // Transfer offscreen buffer to screen.
+            if (!mDirtyRect.isEmpty()) {
+                mOffscreenSrcRect.set(mDirtyRect);
+                mOffscreenSrcRect.offset(0, mOffscreenOffsetY);
+                canvas.drawBitmap(mOffscreenBuffer, mOffscreenSrcRect, mDirtyRect, null);
+                // Note: Defer clearing the dirty rectangle here because we will get cleared
+                // rectangle on the canvas.
+            }
         }
         mGestureFloatingPreviewText.onDraw(canvas);
         if (mShowSlidingKeyInputPreview) {
@@ -249,10 +236,8 @@
             offscreenCanvas.drawRect(dirtyRect, paint);
         }
         dirtyRect.setEmpty();
-
-        // Draw gesture trails to offscreen buffer.
-        offscreenCanvas.translate(0, mOffscreenOffsetY);
         boolean needsUpdatingGesturePreviewTrail = false;
+        // Draw gesture trails to offscreen buffer.
         synchronized (mGesturePreviewTrails) {
             // Trails count == fingers count that have ever been active.
             final int trailsCount = mGesturePreviewTrails.size();
@@ -265,30 +250,15 @@
                 dirtyRect.union(mGesturePreviewTrailBoundsRect);
             }
         }
-        offscreenCanvas.translate(0, -mOffscreenOffsetY);
-
-        // Clip dirty rectangle with offscreen buffer width/height.
-        dirtyRect.offset(0, mOffscreenOffsetY);
-        clipRect(dirtyRect, 0, 0, mOffscreenWidth, mOffscreenHeight);
         return needsUpdatingGesturePreviewTrail;
     }
 
-    private static void clipRect(final Rect out, final int left, final int top, final int right,
-            final int bottom) {
-        out.set(Math.max(out.left, left), Math.max(out.top, top), Math.min(out.right, right),
-                Math.min(out.bottom, bottom));
-    }
-
     public void setGestureFloatingPreviewText(final SuggestedWords suggestedWords) {
         if (!mGestureFloatingPreviewText.isPreviewEnabled()) return;
         mGestureFloatingPreviewText.setSuggetedWords(suggestedWords);
         invalidate();
     }
 
-    public void dismissGestureFloatingPreviewText() {
-        mDrawingHandler.dismissGestureFloatingPreviewText();
-    }
-
     private void drawSlidingKeyInputPreview(final Canvas canvas) {
         // TODO: Implement rubber band preview
     }
diff --git a/java/src/com/android/inputmethod/keyboard/internal/RoundedLine.java b/java/src/com/android/inputmethod/keyboard/internal/RoundedLine.java
index 1f52520..cd6efc4 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/RoundedLine.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/RoundedLine.java
@@ -15,6 +15,7 @@
 package com.android.inputmethod.keyboard.internal;
 
 import android.graphics.Path;
+import android.graphics.Rect;
 import android.graphics.RectF;
 
 public final class RoundedLine {
@@ -100,4 +101,10 @@
         mPath.close();
         return mPath;
     }
+
+    public void getBounds(final Rect outBounds) {
+        // Reuse mArc1 as working variable
+        mPath.computeBounds(mArc1, true /* unused */);
+        mArc1.roundOut(outBounds);
+    }
 }
diff --git a/java/src/com/android/inputmethod/latin/BinaryDictionary.java b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
index 448d25c..27af3d1 100644
--- a/java/src/com/android/inputmethod/latin/BinaryDictionary.java
+++ b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
@@ -35,24 +35,16 @@
     public static final String DICTIONARY_PACK_AUTHORITY =
             "com.android.inputmethod.latin.dictionarypack";
 
-    /**
-     * There is a difference between what java and native code can handle.
-     * This value should only be used in BinaryDictionary.java
-     * It is necessary to keep it at this value because some languages e.g. German have
-     * really long words.
-     */
+    // Must be identical to MAX_WORD_LENGTH in native/jni/src/defines.h
     private static final int MAX_WORD_LENGTH = Constants.Dictionary.MAX_WORD_LENGTH;
-    private static final int MAX_WORDS = 18;
-    private static final int MAX_SPACES = 16;
-
-    private static final int MAX_PREDICTIONS = 60;
-    private static final int MAX_RESULTS = Math.max(MAX_PREDICTIONS, MAX_WORDS);
+    // Must be identical to MAX_RESULTS in native/jni/src/defines.h
+    private static final int MAX_RESULTS = 18;
 
     private long mNativeDict;
     private final Locale mLocale;
     private final int[] mInputCodePoints = new int[MAX_WORD_LENGTH];
     private final int[] mOutputCodePoints = new int[MAX_WORD_LENGTH * MAX_RESULTS];
-    private final int[] mSpaceIndices = new int[MAX_SPACES];
+    private final int[] mSpaceIndices = new int[MAX_RESULTS];
     private final int[] mOutputScores = new int[MAX_RESULTS];
     private final int[] mOutputTypes = new int[MAX_RESULTS];
 
@@ -80,16 +72,14 @@
     /**
      * Constructor for the binary dictionary. This is supposed to be called from the
      * dictionary factory.
-     * @param context the context to access the environment from.
      * @param filename the name of the file to read through native code.
      * @param offset the offset of the dictionary data within the file.
      * @param length the length of the binary data.
      * @param useFullEditDistance whether to use the full edit distance in suggestions
      * @param dictType the dictionary type, as a human-readable string
      */
-    public BinaryDictionary(final Context context, final String filename, final long offset,
-            final long length, final boolean useFullEditDistance, final Locale locale,
-            final String dictType) {
+    public BinaryDictionary(final String filename, final long offset, final long length,
+            final boolean useFullEditDistance, final Locale locale, final String dictType) {
         super(dictType);
         mLocale = locale;
         mUseFullEditDistance = useFullEditDistance;
@@ -100,24 +90,22 @@
         JniUtils.loadNativeLibrary();
     }
 
-    private native long openNative(String sourceDir, long dictOffset, long dictSize,
-            int maxWordLength, int maxWords, int maxPredictions);
-    private native void closeNative(long dict);
-    private native int getFrequencyNative(long dict, int[] word);
-    private native boolean isValidBigramNative(long dict, int[] word1, int[] word2);
-    private native int getSuggestionsNative(long dict, long proximityInfo, long traverseSession,
-            int[] xCoordinates, int[] yCoordinates, int[] times, int[] pointerIds,
-            int[] inputCodePoints, int codesSize, int commitPoint, boolean isGesture,
-            int[] prevWordCodePointArray, boolean useFullEditDistance, int[] outputCodePoints,
-            int[] outputScores, int[] outputIndices, int[] outputTypes);
+    private static native long openNative(String sourceDir, long dictOffset, long dictSize);
+    private static native void closeNative(long dict);
+    private static native int getFrequencyNative(long dict, int[] word);
+    private static native boolean isValidBigramNative(long dict, int[] word1, int[] word2);
+    private static native int getSuggestionsNative(long dict, long proximityInfo,
+            long traverseSession, int[] xCoordinates, int[] yCoordinates, int[] times,
+            int[] pointerIds, int[] inputCodePoints, int inputSize, int commitPoint,
+            boolean isGesture, int[] prevWordCodePointArray, boolean useFullEditDistance,
+            int[] outputCodePoints, int[] outputScores, int[] outputIndices, int[] outputTypes);
     private static native float calcNormalizedScoreNative(int[] before, int[] after, int score);
     private static native int editDistanceNative(int[] before, int[] after);
 
     // TODO: Move native dict into session
     private final void loadDictionary(final String path, final long startOffset,
             final long length) {
-        mNativeDict = openNative(path, startOffset, length, MAX_WORD_LENGTH, MAX_WORDS,
-                MAX_PREDICTIONS);
+        mNativeDict = openNative(path, startOffset, length);
     }
 
     @Override
@@ -146,16 +134,14 @@
         }
 
         final InputPointers ips = composer.getInputPointers();
-        final int codesSize = isGesture ? ips.getPointerSize() : composerSize;
+        final int inputSize = isGesture ? ips.getPointerSize() : composerSize;
         // proximityInfo and/or prevWordForBigrams may not be null.
-        final int tmpCount = getSuggestionsNative(mNativeDict,
-                proximityInfo.getNativeProximityInfo(), getTraverseSession(sessionId).getSession(),
-                ips.getXCoordinates(), ips.getYCoordinates(), ips.getTimes(), ips.getPointerIds(),
-                mInputCodePoints, codesSize, 0 /* commitPoint */, isGesture, prevWordCodePointArray,
+        final int count = getSuggestionsNative(mNativeDict, proximityInfo.getNativeProximityInfo(),
+                getTraverseSession(sessionId).getSession(), ips.getXCoordinates(),
+                ips.getYCoordinates(), ips.getTimes(), ips.getPointerIds(), mInputCodePoints,
+                inputSize, 0 /* commitPoint */, isGesture, prevWordCodePointArray,
                 mUseFullEditDistance, mOutputCodePoints, mOutputScores, mSpaceIndices,
                 mOutputTypes);
-        final int count = Math.min(tmpCount, MAX_PREDICTIONS);
-
         final ArrayList<SuggestedWordInfo> suggestions = CollectionUtils.newArrayList();
         for (int j = 0; j < count; ++j) {
             if (composerSize > 0 && mOutputScores[j] < 1) break;
diff --git a/java/src/com/android/inputmethod/latin/Constants.java b/java/src/com/android/inputmethod/latin/Constants.java
index 3a77724..483504c 100644
--- a/java/src/com/android/inputmethod/latin/Constants.java
+++ b/java/src/com/android/inputmethod/latin/Constants.java
@@ -127,6 +127,7 @@
     }
 
     public static final class Dictionary {
+        // Must be identical to MAX_WORD_LENGTH in native/jni/src/defines.h
         public static final int MAX_WORD_LENGTH = 48;
 
         private Dictionary() {
@@ -183,8 +184,9 @@
     public static final int CODE_ACTION_PREVIOUS = -9;
     public static final int CODE_LANGUAGE_SWITCH = -10;
     public static final int CODE_RESEARCH = -11;
+    public static final int CODE_SHIFT_ENTER = -12;
     // Code value representing the code is not specified.
-    public static final int CODE_UNSPECIFIED = -12;
+    public static final int CODE_UNSPECIFIED = -13;
 
     public static boolean isLetterCode(final int code) {
         return code >= CODE_SPACE;
diff --git a/java/src/com/android/inputmethod/latin/DebugSettings.java b/java/src/com/android/inputmethod/latin/DebugSettings.java
index d1792a3..9be8784 100644
--- a/java/src/com/android/inputmethod/latin/DebugSettings.java
+++ b/java/src/com/android/inputmethod/latin/DebugSettings.java
@@ -107,6 +107,9 @@
         String version = "";
         try {
             final Context context = getActivity();
+            if (context == null) {
+                return;
+            }
             final String packageName = context.getPackageName();
             PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
             version = "Version " + info.versionName;
diff --git a/java/src/com/android/inputmethod/latin/DicTraverseSession.java b/java/src/com/android/inputmethod/latin/DicTraverseSession.java
index ce1b646..534e211 100644
--- a/java/src/com/android/inputmethod/latin/DicTraverseSession.java
+++ b/java/src/com/android/inputmethod/latin/DicTraverseSession.java
@@ -23,10 +23,10 @@
         JniUtils.loadNativeLibrary();
     }
 
-    private native long setDicTraverseSessionNative(String locale);
-    private native void initDicTraverseSessionNative(long nativeDicTraverseSession,
+    private static native long setDicTraverseSessionNative(String locale);
+    private static native void initDicTraverseSessionNative(long nativeDicTraverseSession,
             long dictionary, int[] previousWord, int previousWordLength);
-    private native void releaseDicTraverseSessionNative(long nativeDicTraverseSession);
+    private static native void releaseDicTraverseSessionNative(long nativeDicTraverseSession);
 
     private long mNativeDicTraverseSession;
 
diff --git a/java/src/com/android/inputmethod/latin/DictionaryFactory.java b/java/src/com/android/inputmethod/latin/DictionaryFactory.java
index f381973..22cf5b3 100644
--- a/java/src/com/android/inputmethod/latin/DictionaryFactory.java
+++ b/java/src/com/android/inputmethod/latin/DictionaryFactory.java
@@ -58,9 +58,8 @@
                 BinaryDictionaryGetter.getDictionaryFiles(locale, context);
         if (null != assetFileList) {
             for (final AssetFileAddress f : assetFileList) {
-                final BinaryDictionary binaryDictionary =
-                        new BinaryDictionary(context, f.mFilename, f.mOffset, f.mLength,
-                                useFullEditDistance, locale, Dictionary.TYPE_MAIN);
+                final BinaryDictionary binaryDictionary = new BinaryDictionary(f.mFilename,
+                        f.mOffset, f.mLength, useFullEditDistance, locale, Dictionary.TYPE_MAIN);
                 if (binaryDictionary.isValidDictionary()) {
                     dictList.add(binaryDictionary);
                 }
@@ -112,7 +111,7 @@
                 Log.e(TAG, "sourceDir is not a file: " + sourceDir);
                 return null;
             }
-            return new BinaryDictionary(context, sourceDir, afd.getStartOffset(), afd.getLength(),
+            return new BinaryDictionary(sourceDir, afd.getStartOffset(), afd.getLength(),
                     false /* useFullEditDistance */, locale, Dictionary.TYPE_MAIN);
         } catch (android.content.res.Resources.NotFoundException e) {
             Log.e(TAG, "Could not find the resource");
@@ -130,17 +129,16 @@
 
     /**
      * Create a dictionary from passed data. This is intended for unit tests only.
-     * @param context the test context to create this data from.
      * @param dictionary the file to read
      * @param startOffset the offset in the file where the data starts
      * @param length the length of the data
      * @param useFullEditDistance whether to use the full edit distance in suggestions
      * @return the created dictionary, or null.
      */
-    public static Dictionary createDictionaryForTest(Context context, File dictionary,
-            long startOffset, long length, final boolean useFullEditDistance, Locale locale) {
+    public static Dictionary createDictionaryForTest(File dictionary, long startOffset, long length,
+            final boolean useFullEditDistance, Locale locale) {
         if (dictionary.isFile()) {
-            return new BinaryDictionary(context, dictionary.getAbsolutePath(), startOffset, length,
+            return new BinaryDictionary(dictionary.getAbsolutePath(), startOffset, length,
                     useFullEditDistance, locale, Dictionary.TYPE_MAIN);
         } else {
             Log.e(TAG, "Could not find the file. path=" + dictionary.getAbsolutePath());
diff --git a/java/src/com/android/inputmethod/latin/ExpandableBinaryDictionary.java b/java/src/com/android/inputmethod/latin/ExpandableBinaryDictionary.java
index 47adaa8..2c7fdcc 100644
--- a/java/src/com/android/inputmethod/latin/ExpandableBinaryDictionary.java
+++ b/java/src/com/android/inputmethod/latin/ExpandableBinaryDictionary.java
@@ -279,9 +279,8 @@
         final long length = file.length();
 
         // Build the new binary dictionary
-        final BinaryDictionary newBinaryDictionary =
-                new BinaryDictionary(mContext, filename, 0, length, true /* useFullEditDistance */,
-                        null, mDictType);
+        final BinaryDictionary newBinaryDictionary = new BinaryDictionary(filename, 0, length,
+                true /* useFullEditDistance */, null, mDictType);
 
         if (mBinaryDictionary != null) {
             // Ensure all threads accessing the current dictionary have finished before swapping in
diff --git a/java/src/com/android/inputmethod/latin/InputTypeUtils.java b/java/src/com/android/inputmethod/latin/InputTypeUtils.java
index 9a4503b..e2eacb3 100644
--- a/java/src/com/android/inputmethod/latin/InputTypeUtils.java
+++ b/java/src/com/android/inputmethod/latin/InputTypeUtils.java
@@ -17,6 +17,7 @@
 package com.android.inputmethod.latin;
 
 import android.text.InputType;
+import android.view.inputmethod.EditorInfo;
 
 public final class InputTypeUtils implements InputType {
     private static final int WEB_TEXT_PASSWORD_INPUT_TYPE =
@@ -35,6 +36,7 @@
         InputType.TYPE_TEXT_VARIATION_URI,
         InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD,
         InputType.TYPE_TEXT_VARIATION_WEB_PASSWORD };
+    public static final int IME_ACTION_CUSTOM_LABEL = EditorInfo.IME_MASK_ACTION + 1;
 
     private InputTypeUtils() {
         // This utility class is not publicly instantiable.
@@ -102,4 +104,20 @@
         }
         return true;
     }
+
+    public static int getImeOptionsActionIdFromEditorInfo(final EditorInfo editorInfo) {
+        final int actionId = editorInfo.imeOptions & EditorInfo.IME_MASK_ACTION;
+        if ((editorInfo.imeOptions & EditorInfo.IME_FLAG_NO_ENTER_ACTION) != 0) {
+            return EditorInfo.IME_ACTION_NONE;
+        } else if (editorInfo.actionLabel != null) {
+            return IME_ACTION_CUSTOM_LABEL;
+        } else {
+            return actionId;
+        }
+    }
+
+    public static int getConcreteActionIdFromEditorInfo(final EditorInfo editorInfo) {
+        final int actionId = getImeOptionsActionIdFromEditorInfo(editorInfo);
+        return actionId == InputTypeUtils.IME_ACTION_CUSTOM_LABEL ? editorInfo.actionId : actionId;
+    }
 }
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index 38f1377..8196252 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -166,6 +166,7 @@
     private boolean mExpectingUpdateSelection;
     private int mDeleteCount;
     private long mLastKeyTime;
+    private int mActionId;
 
     // Member variables for remembering the current device orientation.
     private int mDisplayOrientation;
@@ -754,6 +755,7 @@
 
         mLastSelectionStart = editorInfo.initialSelStart;
         mLastSelectionEnd = editorInfo.initialSelEnd;
+        mActionId = InputTypeUtils.getConcreteActionIdFromEditorInfo(editorInfo);
 
         mHandler.cancelUpdateSuggestionStrip();
         mHandler.cancelDoubleSpacePeriodTimer();
@@ -1131,7 +1133,7 @@
             commitChosenWord(typedWord, LastComposedWord.COMMIT_TYPE_USER_TYPED_WORD,
                     separatorString);
             if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.getInstance().onWordFinished(typedWord);
+                ResearchLogger.getInstance().onWordFinished(typedWord, mWordComposer.isBatchMode());
             }
         }
     }
@@ -1163,7 +1165,7 @@
     }
 
     private void swapSwapperAndSpace() {
-        CharSequence lastTwo = mConnection.getTextBeforeCursor(2, 0);
+        final CharSequence lastTwo = mConnection.getTextBeforeCursor(2, 0);
         // It is guaranteed lastTwo.charAt(1) is a swapper - else this method is not called.
         if (lastTwo != null && lastTwo.length() == 2
                 && lastTwo.charAt(0) == Constants.CODE_SPACE) {
@@ -1171,7 +1173,7 @@
             final String text = lastTwo.charAt(1) + " ";
             mConnection.commitText(text, 1);
             if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.latinIME_swapSwapperAndSpace(text);
+                ResearchLogger.latinIME_swapSwapperAndSpace(lastTwo, text);
             }
             mKeyboardSwitcher.updateShiftState();
         }
@@ -1191,7 +1193,8 @@
             final String textToInsert = ". ";
             mConnection.commitText(textToInsert, 1);
             if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.latinIME_maybeDoubleSpacePeriod(textToInsert);
+                ResearchLogger.latinIME_maybeDoubleSpacePeriod(textToInsert,
+                        false /* isBatchMode */);
             }
             mKeyboardSwitcher.updateShiftState();
             return true;
@@ -1271,10 +1274,6 @@
         return mOptionsDialog != null && mOptionsDialog.isShowing();
     }
 
-    private static int getActionId(final Keyboard keyboard) {
-        return keyboard != null ? keyboard.mId.imeActionId() : EditorInfo.IME_ACTION_NONE;
-    }
-
     private void performEditorAction(final int actionId) {
         mConnection.performEditorAction(actionId);
     }
@@ -1300,13 +1299,13 @@
     }
 
     private void sendKeyCodePoint(final int code) {
+        if (ProductionFlag.IS_EXPERIMENTAL) {
+            ResearchLogger.latinIME_sendKeyCodePoint(code);
+        }
         // TODO: Remove this special handling of digit letters.
         // For backward compatibility. See {@link InputMethodService#sendKeyChar(char)}.
         if (code >= '0' && code <= '9') {
             sendDownUpKeyEventForBackwardCompatibility(code - '0' + KeyEvent.KEYCODE_0);
-            if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.latinIME_sendKeyCodePoint(code);
-            }
             return;
         }
 
@@ -1326,6 +1325,9 @@
     // Implementation of {@link KeyboardActionListener}.
     @Override
     public void onCodeInput(final int primaryCode, final int x, final int y) {
+        if (ProductionFlag.IS_EXPERIMENTAL) {
+            ResearchLogger.latinIME_onCodeInput(primaryCode, x, y);
+        }
         final long when = SystemClock.uptimeMillis();
         if (primaryCode != Constants.CODE_DELETE || when > mLastKeyTime + QUICK_PRESS) {
             mDeleteCount = 0;
@@ -1365,9 +1367,6 @@
         case Constants.CODE_SHORTCUT:
             mSubtypeSwitcher.switchToShortcutIME(this);
             break;
-        case Constants.CODE_ACTION_ENTER:
-            performEditorAction(getActionId(switcher.getKeyboard()));
-            break;
         case Constants.CODE_ACTION_NEXT:
             performEditorAction(EditorInfo.IME_ACTION_NEXT);
             break;
@@ -1382,32 +1381,19 @@
                 ResearchLogger.getInstance().onResearchKeySelected(this);
             }
             break;
-        default:
-            mSpaceState = SPACE_STATE_NONE;
-            if (mSettings.getCurrent().isWordSeparator(primaryCode)) {
-                didAutoCorrect = handleSeparator(primaryCode, x, y, spaceState);
-            } else {
-                if (SPACE_STATE_PHANTOM == spaceState) {
-                    if (ProductionFlag.IS_INTERNAL) {
-                        if (mWordComposer.isComposingWord() && mWordComposer.isBatchMode()) {
-                            Stats.onAutoCorrection(
-                                    "", mWordComposer.getTypedWord(), " ", mWordComposer);
-                        }
-                    }
-                    commitTyped(LastComposedWord.NOT_A_SEPARATOR);
-                }
-                final int keyX, keyY;
-                final Keyboard keyboard = mKeyboardSwitcher.getKeyboard();
-                if (keyboard != null && keyboard.hasProximityCharsCorrection(primaryCode)) {
-                    keyX = x;
-                    keyY = y;
-                } else {
-                    keyX = Constants.NOT_A_COORDINATE;
-                    keyY = Constants.NOT_A_COORDINATE;
-                }
-                handleCharacter(primaryCode, keyX, keyY, spaceState);
+        case Constants.CODE_ACTION_ENTER:
+            if (EditorInfo.IME_ACTION_NONE != mActionId
+                && EditorInfo.IME_ACTION_UNSPECIFIED != mActionId) {
+                performEditorAction(mActionId);
+                break;
             }
-            mExpectingUpdateSelection = true;
+            didAutoCorrect = handleNonSpecialCharacter(Constants.CODE_ENTER, x, y, spaceState);
+            break;
+        case Constants.CODE_SHIFT_ENTER:
+            didAutoCorrect = handleNonSpecialCharacter(Constants.CODE_ENTER, x, y, spaceState);
+            break;
+        default:
+            didAutoCorrect = handleNonSpecialCharacter(primaryCode, x, y, spaceState);
             break;
         }
         switcher.onCodeInput(primaryCode);
@@ -1419,9 +1405,38 @@
             mEnteredText = null;
         }
         mConnection.endBatchEdit();
-        if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.latinIME_onCodeInput(primaryCode, x, y);
+    }
+
+    private boolean handleNonSpecialCharacter(final int primaryCode, final int x, final int y,
+            final int spaceState) {
+        mSpaceState = SPACE_STATE_NONE;
+        final boolean didAutoCorrect;
+        if (mSettings.getCurrent().isWordSeparator(primaryCode)) {
+            didAutoCorrect = handleSeparator(primaryCode, x, y, spaceState);
+        } else {
+            didAutoCorrect = false;
+            if (SPACE_STATE_PHANTOM == spaceState) {
+                if (ProductionFlag.IS_INTERNAL) {
+                    if (mWordComposer.isComposingWord() && mWordComposer.isBatchMode()) {
+                        Stats.onAutoCorrection(
+                                "", mWordComposer.getTypedWord(), " ", mWordComposer);
+                    }
+                }
+                commitTyped(LastComposedWord.NOT_A_SEPARATOR);
+            }
+            final int keyX, keyY;
+            final Keyboard keyboard = mKeyboardSwitcher.getKeyboard();
+            if (keyboard != null && keyboard.hasProximityCharsCorrection(primaryCode)) {
+                keyX = x;
+                keyY = y;
+            } else {
+                keyX = Constants.NOT_A_COORDINATE;
+                keyY = Constants.NOT_A_COORDINATE;
+            }
+            handleCharacter(primaryCode, keyX, keyY, spaceState);
         }
+        mExpectingUpdateSelection = true;
+        return didAutoCorrect;
     }
 
     // Called from PointerTracker through the KeyboardActionListener interface
@@ -1440,7 +1455,7 @@
         }
         mConnection.commitText(text, 1);
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.latinIME_onTextInput(text);
+            ResearchLogger.latinIME_onTextInput(text, false /* isBatchMode */);
         }
         mConnection.endBatchEdit();
         // Space state must be updated before calling updateShiftState
@@ -1587,10 +1602,9 @@
             final boolean dismissGestureFloatingPreviewText) {
         showSuggestionStrip(suggestedWords, null);
         final KeyboardView mainKeyboardView = mKeyboardSwitcher.getMainKeyboardView();
+        mainKeyboardView.showGestureFloatingPreviewText(suggestedWords);
         if (dismissGestureFloatingPreviewText) {
             mainKeyboardView.dismissGestureFloatingPreviewText();
-        } else {
-            mainKeyboardView.showGestureFloatingPreviewText(suggestedWords);
         }
     }
 
@@ -1665,10 +1679,13 @@
             final int length = mWordComposer.size();
             if (length > 0) {
                 if (mWordComposer.isBatchMode()) {
-                    mWordComposer.reset();
                     if (ProductionFlag.IS_EXPERIMENTAL) {
-                        ResearchLogger.latinIME_handleBackspace_batch(mWordComposer.getTypedWord());
+                        final String word = mWordComposer.getTypedWord();
+                        ResearchLogger.latinIME_handleBackspace_batch(word, 1);
+                        ResearchLogger.getInstance().uncommitCurrentLogUnit(
+                                word, false /* dumpCurrentLogUnit */);
                     }
+                    mWordComposer.reset();
                 } else {
                     mWordComposer.deleteLast();
                 }
@@ -1715,14 +1732,17 @@
             // We should backspace one char and restart suggestion if at the end of a word.
             if (mLastSelectionStart != mLastSelectionEnd) {
                 // If there is a selection, remove it.
-                final int lengthToDelete = mLastSelectionEnd - mLastSelectionStart;
+                final int numCharsDeleted = mLastSelectionEnd - mLastSelectionStart;
                 mConnection.setSelection(mLastSelectionEnd, mLastSelectionEnd);
                 // Reset mLastSelectionEnd to mLastSelectionStart. This is what is supposed to
                 // happen, and if it's wrong, the next call to onUpdateSelection will correct it,
                 // but we want to set it right away to avoid it being used with the wrong values
                 // later (typically, in a subsequent press on backspace).
                 mLastSelectionEnd = mLastSelectionStart;
-                mConnection.deleteSurroundingText(lengthToDelete, 0);
+                mConnection.deleteSurroundingText(numCharsDeleted, 0);
+                if (ProductionFlag.IS_EXPERIMENTAL) {
+                    ResearchLogger.latinIME_handleBackspace(numCharsDeleted);
+                }
             } else {
                 // There is no selection, just delete one character.
                 if (NOT_A_CURSOR_POSITION == mLastSelectionEnd) {
@@ -1739,8 +1759,14 @@
                 } else {
                     mConnection.deleteSurroundingText(1, 0);
                 }
+                if (ProductionFlag.IS_EXPERIMENTAL) {
+                    ResearchLogger.latinIME_handleBackspace(1);
+                }
                 if (mDeleteCount > DELETE_ACCELERATE_AT) {
                     mConnection.deleteSurroundingText(1, 0);
+                    if (ProductionFlag.IS_EXPERIMENTAL) {
+                        ResearchLogger.latinIME_handleBackspace(1);
+                    }
                 }
             }
             if (mSettings.getCurrent().isSuggestionsRequested(mDisplayOrientation)) {
@@ -1840,6 +1866,9 @@
     // Returns true if we did an autocorrection, false otherwise.
     private boolean handleSeparator(final int primaryCode, final int x, final int y,
             final int spaceState) {
+        if (ProductionFlag.IS_EXPERIMENTAL) {
+            ResearchLogger.recordTimeForLogUnitSplit();
+        }
         boolean didAutoCorrect = false;
         // Handle separator
         if (mWordComposer.isComposingWord()) {
@@ -2084,7 +2113,7 @@
             }
             if (ProductionFlag.IS_EXPERIMENTAL) {
                 ResearchLogger.latinIme_commitCurrentAutoCorrection(typedWord, autoCorrection,
-                        separatorString);
+                        separatorString, mWordComposer.isBatchMode());
             }
             mExpectingUpdateSelection = true;
             commitChosenWord(autoCorrection, LastComposedWord.COMMIT_TYPE_DECIDED_WORD,
@@ -2118,7 +2147,8 @@
             onCodeInput(primaryCode,
                     Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE);
             if (ProductionFlag.IS_EXPERIMENTAL) {
-                ResearchLogger.latinIME_punctuationSuggestion(index, suggestion);
+                ResearchLogger.latinIME_punctuationSuggestion(index, suggestion,
+                        false /* isBatchMode */, suggestedWords.mIsPrediction);
             }
             return;
         }
@@ -2157,7 +2187,8 @@
         commitChosenWord(suggestion, LastComposedWord.COMMIT_TYPE_MANUAL_PICK,
                 LastComposedWord.NOT_A_SEPARATOR);
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.latinIME_pickSuggestionManually(replacedWord, index, suggestion);
+            ResearchLogger.latinIME_pickSuggestionManually(replacedWord, index, suggestion,
+                    mWordComposer.isBatchMode());
         }
         mConnection.endBatchEdit();
         // Don't allow cancellation of manual pick
@@ -2254,6 +2285,12 @@
                 mConnection.getWordBeforeCursorIfAtEndOfWord(mSettings.getCurrent());
         if (null != word) {
             restartSuggestionsOnWordBeforeCursor(word);
+            // TODO: Handle the case where the user manually moves the cursor and then backs up over
+            // a separator.  In that case, the current log unit should not be uncommitted.
+            if (ProductionFlag.IS_EXPERIMENTAL) {
+                ResearchLogger.getInstance().uncommitCurrentLogUnit(word.toString(),
+                        true /* dumpCurrentLogUnit */);
+            }
         }
     }
 
@@ -2297,7 +2334,10 @@
                     Constants.NOT_A_COORDINATE, Constants.NOT_A_COORDINATE);
         }
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.latinIME_revertCommit(committedWord, originallyTypedWord);
+            ResearchLogger.latinIME_revertCommit(committedWord, originallyTypedWord,
+                    mWordComposer.isBatchMode(), mLastComposedWord.mSeparatorString);
+            ResearchLogger.getInstance().uncommitCurrentLogUnit(committedWord,
+                    true /* dumpCurrentLogUnit */);
         }
         // Don't restart suggestion yet. We'll restart if the user deletes the
         // separator.
@@ -2310,6 +2350,9 @@
     public void promotePhantomSpace() {
         if (mSettings.getCurrent().shouldInsertSpacesAutomatically()) {
             sendKeyCodePoint(Constants.CODE_SPACE);
+            if (ProductionFlag.IS_EXPERIMENTAL) {
+                ResearchLogger.latinIME_promotePhantomSpace();
+            }
         }
     }
 
diff --git a/java/src/com/android/inputmethod/latin/RichInputConnection.java b/java/src/com/android/inputmethod/latin/RichInputConnection.java
index 0d3ebac..f7268fc 100644
--- a/java/src/com/android/inputmethod/latin/RichInputConnection.java
+++ b/java/src/com/android/inputmethod/latin/RichInputConnection.java
@@ -648,19 +648,20 @@
         // Here we test whether we indeed have a period and a space before us. This should not
         // be needed, but it's there just in case something went wrong.
         final CharSequence textBeforeCursor = getTextBeforeCursor(2, 0);
-        if (!". ".equals(textBeforeCursor)) {
+        final String periodSpace = ". ";
+        if (!periodSpace.equals(textBeforeCursor)) {
             // Theoretically we should not be coming here if there isn't ". " before the
             // cursor, but the application may be changing the text while we are typing, so
             // anything goes. We should not crash.
             Log.d(TAG, "Tried to revert double-space combo but we didn't find "
-                    + "\". \" just before the cursor.");
+                    + "\"" + periodSpace + "\" just before the cursor.");
             return false;
         }
         deleteSurroundingText(2, 0);
         final String doubleSpace = "  ";
         commitText(doubleSpace, 1);
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.richInputConnection_revertDoubleSpacePeriod(doubleSpace);
+            ResearchLogger.richInputConnection_revertDoubleSpacePeriod();
         }
         return true;
     }
@@ -685,7 +686,7 @@
         final String text = " " + textBeforeCursor.subSequence(0, 1);
         commitText(text, 1);
         if (ProductionFlag.IS_EXPERIMENTAL) {
-            ResearchLogger.richInputConnection_revertSwapPunctuation(text);
+            ResearchLogger.richInputConnection_revertSwapPunctuation();
         }
         return true;
     }
diff --git a/java/src/com/android/inputmethod/latin/Settings.java b/java/src/com/android/inputmethod/latin/Settings.java
index f592a25..c5930a9 100644
--- a/java/src/com/android/inputmethod/latin/Settings.java
+++ b/java/src/com/android/inputmethod/latin/Settings.java
@@ -135,7 +135,6 @@
 
     public static int readKeyPreviewPopupDismissDelay(final SharedPreferences prefs,
             final Resources res) {
-        // TODO: use mKeyPreviewPopupDismissDelayRawValue instead of reading it again here.
         return Integer.parseInt(prefs.getString(PREF_KEY_PREVIEW_POPUP_DISMISS_DELAY,
                 Integer.toString(res.getInteger(
                         R.integer.config_key_preview_linger_timeout))));
@@ -186,7 +185,6 @@
     }
 
     public static boolean readUsabilityStudyMode(final SharedPreferences prefs) {
-        // TODO: use mUsabilityStudyMode instead of reading it again here
         return prefs.getBoolean(DebugSettings.PREF_USABILITY_STUDY_MODE, true);
     }
 
diff --git a/java/src/com/android/inputmethod/latin/SettingsValues.java b/java/src/com/android/inputmethod/latin/SettingsValues.java
index fac85a8..9a20246 100644
--- a/java/src/com/android/inputmethod/latin/SettingsValues.java
+++ b/java/src/com/android/inputmethod/latin/SettingsValues.java
@@ -51,14 +51,8 @@
     public final boolean mSoundOn;
     public final boolean mKeyPreviewPopupOn;
     private final String mVoiceMode;
-    private final String mAutoCorrectionThresholdRawValue;
-    public final String mShowSuggestionsSetting;
-    @SuppressWarnings("unused") // TODO: Use this
-    private final boolean mUsabilityStudyMode;
     public final boolean mIncludesOtherImesInLanguageSwitchList;
     public final boolean mShowsLanguageSwitchKey;
-    @SuppressWarnings("unused") // TODO: Use this
-    private final String mKeyPreviewPopupDismissDelayRawValue;
     public final boolean mUseContactsDict;
     public final boolean mUseDoubleSpacePeriod;
     // Use bigrams to predict the next word when there is no input for it yet
@@ -122,20 +116,15 @@
         final String voiceModeMain = res.getString(R.string.voice_mode_main);
         final String voiceModeOff = res.getString(R.string.voice_mode_off);
         mVoiceMode = prefs.getString(Settings.PREF_VOICE_MODE, voiceModeMain);
-        mAutoCorrectionThresholdRawValue = prefs.getString(Settings.PREF_AUTO_CORRECTION_THRESHOLD,
+        final String autoCorrectionThresholdRawValue = prefs.getString(
+                Settings.PREF_AUTO_CORRECTION_THRESHOLD,
                 res.getString(R.string.auto_correction_threshold_mode_index_modest));
-        mShowSuggestionsSetting = prefs.getString(Settings.PREF_SHOW_SUGGESTIONS_SETTING,
-                res.getString(R.string.prefs_suggestion_visibility_default_value));
-        mUsabilityStudyMode = Settings.readUsabilityStudyMode(prefs);
         mIncludesOtherImesInLanguageSwitchList = prefs.getBoolean(
                 Settings.PREF_INCLUDE_OTHER_IMES_IN_LANGUAGE_SWITCH_LIST, false);
         mShowsLanguageSwitchKey = Settings.readShowsLanguageSwitchKey(prefs);
-        mKeyPreviewPopupDismissDelayRawValue = prefs.getString(
-                Settings.PREF_KEY_PREVIEW_POPUP_DISMISS_DELAY,
-                Integer.toString(res.getInteger(R.integer.config_key_preview_linger_timeout)));
         mUseContactsDict = prefs.getBoolean(Settings.PREF_KEY_USE_CONTACTS_DICT, true);
         mUseDoubleSpacePeriod = prefs.getBoolean(Settings.PREF_KEY_USE_DOUBLE_SPACE_PERIOD, true);
-        mAutoCorrectEnabled = readAutoCorrectEnabled(res, mAutoCorrectionThresholdRawValue);
+        mAutoCorrectEnabled = readAutoCorrectEnabled(res, autoCorrectionThresholdRawValue);
         mBigramPredictionEnabled = readBigramPredictionEnabled(prefs, res);
 
         // Compute other readable settings
@@ -143,7 +132,7 @@
         mKeypressSoundVolume = Settings.readKeypressSoundVolume(prefs, res);
         mKeyPreviewPopupDismissDelay = Settings.readKeyPreviewPopupDismissDelay(prefs, res);
         mAutoCorrectionThreshold = readAutoCorrectionThreshold(res,
-                mAutoCorrectionThresholdRawValue);
+                autoCorrectionThresholdRawValue);
         mVoiceKeyEnabled = mVoiceMode != null && !mVoiceMode.equals(voiceModeOff);
         mVoiceKeyOnMain = mVoiceMode != null && mVoiceMode.equals(voiceModeMain);
         final boolean gestureInputEnabledByBuildConfig = res.getBoolean(
@@ -154,7 +143,10 @@
         mGestureFloatingPreviewTextEnabled = prefs.getBoolean(
                 Settings.PREF_GESTURE_FLOATING_PREVIEW_TEXT, true);
         mCorrectionEnabled = mAutoCorrectEnabled && !mInputAttributes.mInputTypeNoAutoCorrect;
-        mSuggestionVisibility = createSuggestionVisibility(res);
+        final String showSuggestionsSetting = prefs.getString(
+                Settings.PREF_SHOW_SUGGESTIONS_SETTING,
+                res.getString(R.string.prefs_suggestion_visibility_default_value));
+        mSuggestionVisibility = createSuggestionVisibility(res, showSuggestionsSetting);
     }
 
     public boolean isApplicationSpecifiedCompletionsOn() {
@@ -271,8 +263,8 @@
         SUGGESTION_VISIBILITY_HIDE_VALUE
     };
 
-    private int createSuggestionVisibility(final Resources res) {
-        final String suggestionVisiblityStr = mShowSuggestionsSetting;
+    private static int createSuggestionVisibility(final Resources res,
+            final String suggestionVisiblityStr) {
         for (int visibility : SUGGESTION_VISIBILITY_VALUE_ARRAY) {
             if (suggestionVisiblityStr.equals(res.getString(visibility))) {
                 return visibility;
diff --git a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java
index fe29084..eb0ec39 100644
--- a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java
+++ b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java
@@ -31,6 +31,7 @@
 import android.view.inputmethod.InputMethodManager;
 import android.view.inputmethod.InputMethodSubtype;
 
+import com.android.inputmethod.annotations.UsedForTesting;
 import com.android.inputmethod.keyboard.KeyboardSwitcher;
 
 import java.util.List;
@@ -239,7 +240,14 @@
         return mNeedsToDisplayLanguage.getValue();
     }
 
+    private static Locale sForcedLocaleForTesting = null;
+    @UsedForTesting
+    void forceLocale(final Locale locale) {
+        sForcedLocaleForTesting = locale;
+    }
+
     public Locale getCurrentSubtypeLocale() {
+        if (null != sForcedLocaleForTesting) return sForcedLocaleForTesting;
         return SubtypeLocale.getSubtypeLocale(getCurrentSubtype());
     }
 
diff --git a/java/src/com/android/inputmethod/latin/Suggest.java b/java/src/com/android/inputmethod/latin/Suggest.java
index 3dc2ba9..2abf75d 100644
--- a/java/src/com/android/inputmethod/latin/Suggest.java
+++ b/java/src/com/android/inputmethod/latin/Suggest.java
@@ -72,9 +72,8 @@
     }
 
     @UsedForTesting
-    Suggest(final Context context, final File dictionary,
-            final long startOffset, final long length, final Locale locale) {
-        final Dictionary mainDict = DictionaryFactory.createDictionaryForTest(context, dictionary,
+    Suggest(final File dictionary, final long startOffset, final long length, final Locale locale) {
+        final Dictionary mainDict = DictionaryFactory.createDictionaryForTest(dictionary,
                 startOffset, length /* useFullEditDistance */, false, locale);
         mLocale = locale;
         mMainDictionary = mainDict;
diff --git a/java/src/com/android/inputmethod/latin/spellcheck/AndroidSpellCheckerService.java b/java/src/com/android/inputmethod/latin/spellcheck/AndroidSpellCheckerService.java
index 89d6c90..907c0cd 100644
--- a/java/src/com/android/inputmethod/latin/spellcheck/AndroidSpellCheckerService.java
+++ b/java/src/com/android/inputmethod/latin/spellcheck/AndroidSpellCheckerService.java
@@ -81,6 +81,7 @@
 
     public static final int SCRIPT_LATIN = 0;
     public static final int SCRIPT_CYRILLIC = 1;
+    public static final int SCRIPT_GREEK = 2;
     public static final String SINGLE_QUOTE = "\u0027";
     public static final String APOSTROPHE = "\u2019";
     private static final TreeMap<String, Integer> mLanguageToScript;
@@ -94,18 +95,23 @@
         // IMPORTANT: this only contains languages - do not write countries in there.
         // Only the language is searched from the map.
         mLanguageToScript = CollectionUtils.newTreeMap();
-        mLanguageToScript.put("en", SCRIPT_LATIN);
-        mLanguageToScript.put("fr", SCRIPT_LATIN);
-        mLanguageToScript.put("de", SCRIPT_LATIN);
-        mLanguageToScript.put("nl", SCRIPT_LATIN);
         mLanguageToScript.put("cs", SCRIPT_LATIN);
+        mLanguageToScript.put("da", SCRIPT_LATIN);
+        mLanguageToScript.put("de", SCRIPT_LATIN);
+        mLanguageToScript.put("el", SCRIPT_GREEK);
+        mLanguageToScript.put("en", SCRIPT_LATIN);
         mLanguageToScript.put("es", SCRIPT_LATIN);
-        mLanguageToScript.put("it", SCRIPT_LATIN);
+        mLanguageToScript.put("fi", SCRIPT_LATIN);
+        mLanguageToScript.put("fr", SCRIPT_LATIN);
         mLanguageToScript.put("hr", SCRIPT_LATIN);
+        mLanguageToScript.put("it", SCRIPT_LATIN);
+        mLanguageToScript.put("lt", SCRIPT_LATIN);
+        mLanguageToScript.put("lv", SCRIPT_LATIN);
+        mLanguageToScript.put("nb", SCRIPT_LATIN);
+        mLanguageToScript.put("nl", SCRIPT_LATIN);
         mLanguageToScript.put("pt", SCRIPT_LATIN);
+        mLanguageToScript.put("sl", SCRIPT_LATIN);
         mLanguageToScript.put("ru", SCRIPT_CYRILLIC);
-        // TODO: Make a persian proximity, and activate the Farsi subtype.
-        // mLanguageToScript.put("fa", SCRIPT_PERSIAN);
     }
 
     @Override public void onCreate() {
diff --git a/java/src/com/android/inputmethod/latin/spellcheck/AndroidWordLevelSpellCheckerSession.java b/java/src/com/android/inputmethod/latin/spellcheck/AndroidWordLevelSpellCheckerSession.java
index 470943b..6581978 100644
--- a/java/src/com/android/inputmethod/latin/spellcheck/AndroidWordLevelSpellCheckerSession.java
+++ b/java/src/com/android/inputmethod/latin/spellcheck/AndroidWordLevelSpellCheckerSession.java
@@ -143,8 +143,17 @@
         case AndroidSpellCheckerService.SCRIPT_CYRILLIC:
             // All Cyrillic characters are in the 400~52F block. There are some in the upper
             // Unicode range, but they are archaic characters that are not used in modern
-            // russian and are not used by our dictionary.
+            // Russian and are not used by our dictionary.
             return codePoint >= 0x400 && codePoint <= 0x52F && Character.isLetter(codePoint);
+        case AndroidSpellCheckerService.SCRIPT_GREEK:
+            // Greek letters are either in the 370~3FF range (Greek & Coptic), or in the
+            // 1F00~1FFF range (Greek extended). Our dictionary contains both sort of characters.
+            // Our dictionary also contains a few words with 0xF2; it would be best to check
+            // if that's correct, but a Google search does return results for these words so
+            // they are probably okay.
+            return (codePoint >= 0x370 && codePoint <= 0x3FF)
+                    || (codePoint >= 0x1F00 && codePoint <= 0x1FFF)
+                    || codePoint == 0xF2;
         default:
             // Should never come here
             throw new RuntimeException("Impossible value of script: " + script);
diff --git a/java/src/com/android/inputmethod/latin/spellcheck/SpellCheckerProximityInfo.java b/java/src/com/android/inputmethod/latin/spellcheck/SpellCheckerProximityInfo.java
index 6c0d79c..572a826 100644
--- a/java/src/com/android/inputmethod/latin/spellcheck/SpellCheckerProximityInfo.java
+++ b/java/src/com/android/inputmethod/latin/spellcheck/SpellCheckerProximityInfo.java
@@ -73,6 +73,12 @@
         // to spell check has been entered with one of the keyboards above. Also, specifically
         // to English, many spelling errors consist of the last vowel of the word being wrong
         // because in English vowels tend to merge with each other in pronunciation.
+        /*
+        The Qwerty layout this represents looks like the following:
+            q w e r t y u i o p
+             a s d f g h j k l
+               z x c v b n m
+        */
         final static int[] PROXIMITY = {
             // Proximity for row 1. This must have exactly ROW_SIZE entries for each letter,
             // and exactly PROXIMITY_GRID_WIDTH letters for a row. Pad with NUL's.
@@ -127,10 +133,13 @@
         final private static TreeMap<Integer, Integer> INDICES = CollectionUtils.newTreeMap();
         // TODO: The following table is solely based on the keyboard layout. Consult with Russian
         // speakers on commonly misspelled words/letters.
-        final static int[] PROXIMITY = {
-            // Proximity for row 1. This must have exactly ROW_SIZE entries for each letter,
-            // and exactly PROXIMITY_GRID_WIDTH letters for a row. Pad with NUL's.
-            // The number of rows must be exactly PROXIMITY_GRID_HEIGHT.
+        /*
+        The Russian layout this represents looks like the following:
+            й ц у к е н г ш щ з х
+            ф ы в а п р о л д ж э
+              я ч с м и т ь б ю
+
+        This gives us the following table:
             'й', 'ц', 'ф', 'ы', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'ц', 'й', 'ф', 'ы', 'в', 'у', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'у', 'ц', 'ы', 'в', 'а', 'к', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
@@ -143,7 +152,6 @@
             'з', 'щ', 'д', 'ж', 'э', 'х', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'х', 'з', 'ж', 'э', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
 
-            // Proximity for row 2. See comment above about size.
             'ф', 'й', 'ц', 'ы', 'я', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'ы', 'й', 'ц', 'у', 'ф', 'в', 'я', 'ч', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'в', 'ц', 'у', 'к', 'ы', 'а', 'я', 'ч', 'с', NUL, NUL, NUL, NUL, NUL, NUL, NUL,
@@ -156,7 +164,6 @@
             'ж', 'щ', 'з', 'х', 'д', 'э', 'б', 'ю', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'э', 'з', 'х', 'ю', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
 
-            // Proximity for row 3. See comment above about size.
             'я', 'ф', 'ы', 'в', 'ч', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'ч', 'ы', 'в', 'а', 'я', 'с', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'с', 'в', 'а', 'п', 'ч', 'м', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
@@ -166,6 +173,249 @@
             'ь', 'о', 'л', 'д', 'т', 'б', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'б', 'л', 'д', 'ж', 'ь', 'ю', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             'ю', 'д', 'ж', 'э', 'б', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+
+        Using the following characters:
+        */
+        private static final int CY_SHORT_I = '\u0439'; // й
+        private static final int CY_TSE = '\u0446'; // ц
+        private static final int CY_U = '\u0443'; // у
+        private static final int CY_KA = '\u043A'; // к
+        private static final int CY_IE = '\u0435'; // е
+        private static final int CY_EN = '\u043D'; // н
+        private static final int CY_GHE = '\u0433'; // г
+        private static final int CY_SHA = '\u0448'; // ш
+        private static final int CY_SHCHA = '\u0449'; // щ
+        private static final int CY_ZE = '\u0437'; // з
+        private static final int CY_HA = '\u0445'; // х
+        private static final int CY_EF = '\u0444'; // ф
+        private static final int CY_YERU = '\u044B'; // ы
+        private static final int CY_VE = '\u0432'; // в
+        private static final int CY_A = '\u0430'; // а
+        private static final int CY_PE = '\u043F'; // п
+        private static final int CY_ER = '\u0440'; // р
+        private static final int CY_O = '\u043E'; // о
+        private static final int CY_EL = '\u043B'; // л
+        private static final int CY_DE = '\u0434'; // д
+        private static final int CY_ZHE = '\u0436'; // ж
+        private static final int CY_E = '\u044D'; // э
+        private static final int CY_YA = '\u044F'; // я
+        private static final int CY_CHE = '\u0447'; // ч
+        private static final int CY_ES = '\u0441'; // с
+        private static final int CY_EM = '\u043C'; // м
+        private static final int CY_I = '\u0438'; // и
+        private static final int CY_TE = '\u0442'; // т
+        private static final int CY_SOFT_SIGN = '\u044C'; // ь
+        private static final int CY_BE = '\u0431'; // б
+        private static final int CY_YU = '\u044E'; // ю
+        final static int[] PROXIMITY = {
+            // Proximity for row 1. This must have exactly ROW_SIZE entries for each letter,
+            // and exactly PROXIMITY_GRID_WIDTH letters for a row. Pad with NUL's.
+            // The number of rows must be exactly PROXIMITY_GRID_HEIGHT.
+            CY_SHORT_I, CY_TSE, CY_EF, CY_YERU, NUL, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_TSE, CY_SHORT_I, CY_EF, CY_YERU, CY_VE, CY_U, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_U, CY_TSE, CY_YERU, CY_VE, CY_A, CY_KA, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_KA, CY_U, CY_VE, CY_A, CY_PE, CY_IE, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_IE, CY_KA, CY_A, CY_PE, CY_ER, CY_EN, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_EN, CY_IE, CY_PE, CY_ER, CY_O, CY_GHE, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_GHE, CY_EN, CY_ER, CY_O, CY_EL, CY_SHA, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_SHA, CY_GHE, CY_O, CY_EL, CY_DE, CY_SHCHA, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_SHCHA, CY_SHA, CY_EL, CY_DE, CY_ZHE, CY_ZE, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_ZE, CY_SHCHA, CY_DE, CY_ZHE, CY_E, CY_HA, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_HA, CY_ZE, CY_ZHE, CY_E, NUL, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+
+            // Proximity for row 2. See comment above about size.
+            CY_EF, CY_SHORT_I, CY_TSE, CY_YERU, CY_YA, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_YERU, CY_SHORT_I, CY_TSE, CY_U, CY_EF, CY_VE, CY_YA, CY_CHE,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_VE, CY_TSE, CY_U, CY_KA, CY_YERU, CY_A, CY_YA, CY_CHE,
+                    CY_ES, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_A, CY_U, CY_KA, CY_IE, CY_VE, CY_PE, CY_CHE, CY_ES,
+                    CY_EM, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_PE, CY_KA, CY_IE, CY_EN, CY_A, CY_ER, CY_ES, CY_EM,
+                    CY_I, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_ER, CY_IE, CY_EN, CY_GHE, CY_PE, CY_O, CY_EM, CY_I,
+                    CY_TE, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_O, CY_EN, CY_GHE, CY_SHA, CY_ER, CY_EL, CY_I, CY_TE,
+                    CY_SOFT_SIGN, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_EL, CY_GHE, CY_SHA, CY_SHCHA, CY_O, CY_DE, CY_TE, CY_SOFT_SIGN,
+                    CY_BE, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_DE, CY_SHA, CY_SHCHA, CY_ZE, CY_EL, CY_ZHE, CY_SOFT_SIGN, CY_BE,
+                    CY_YU, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_ZHE, CY_SHCHA, CY_ZE, CY_HA, CY_DE, CY_E, CY_BE, CY_YU,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_E, CY_ZE, CY_HA, CY_YU, NUL, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+
+            // Proximity for row 3. See comment above about size.
+            CY_YA, CY_EF, CY_YERU, CY_VE, CY_CHE, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_CHE, CY_YERU, CY_VE, CY_A, CY_YA, CY_ES, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_ES, CY_VE, CY_A, CY_PE, CY_CHE, CY_EM, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_EM, CY_A, CY_PE, CY_ER, CY_ES, CY_I, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_I, CY_PE, CY_ER, CY_O, CY_EM, CY_TE, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_TE, CY_ER, CY_O, CY_EL, CY_I, CY_SOFT_SIGN, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_SOFT_SIGN, CY_O, CY_EL, CY_DE, CY_TE, CY_BE, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_BE, CY_EL, CY_DE, CY_ZHE, CY_SOFT_SIGN, CY_YU, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            CY_YU, CY_DE, CY_ZHE, CY_E, CY_BE, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+        };
+        static {
+            buildProximityIndices(PROXIMITY, INDICES);
+        }
+        static int getIndexOf(int characterCode) {
+            return computeIndex(characterCode, INDICES);
+        }
+    }
+
+    private static final class Greek {
+        final private static TreeMap<Integer, Integer> INDICES = CollectionUtils.newTreeMap();
+        // TODO: The following table is solely based on the keyboard layout. Consult with Greek
+        // speakers on commonly misspelled words/letters.
+        /*
+        The Greek layout this represents looks like the following:
+            ; ς ε ρ τ υ θ ι ο π
+             α σ δ φ γ η ξ κ λ
+               ζ χ ψ ω β ν μ
+
+        This gives us the following table:
+            'ς', 'ε', 'α', 'σ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'ε', 'ς', 'ρ', 'σ', 'δ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'ρ', 'ε', 'τ', 'δ', 'φ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'τ', 'ρ', 'υ', 'φ', 'γ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'υ', 'τ', 'θ', 'γ', 'η', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'θ', 'υ', 'ι', 'η', 'ξ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'ι', 'θ', 'ο', 'ξ', 'κ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'ο', 'ι', 'π', 'κ', 'λ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'π', 'ο', 'λ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+
+            'α', 'ς', 'σ', 'ζ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'σ', 'ς', 'ε', 'α', 'δ', 'ζ', 'χ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'δ', 'ε', 'ρ', 'σ', 'φ', 'ζ', 'χ', 'ψ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'φ', 'ρ', 'τ', 'δ', 'γ', 'χ', 'ψ', 'ω', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'γ', 'τ', 'υ', 'φ', 'η', 'ψ', 'ω', 'β', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'η', 'υ', 'θ', 'γ', 'ξ', 'ω', 'β', 'ν', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'ξ', 'θ', 'ι', 'η', 'κ', 'β', 'ν', 'μ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'κ', 'ι', 'ο', 'ξ', 'λ', 'ν', 'μ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'λ', 'ο', 'π', 'κ', 'μ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+
+            'ζ', 'α', 'σ', 'δ', 'χ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'χ', 'σ', 'δ', 'φ', 'ζ', 'ψ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'ψ', 'δ', 'φ', 'γ', 'χ', 'ω', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'ω', 'φ', 'γ', 'η', 'ψ', 'β', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'β', 'γ', 'η', 'ξ', 'ω', 'ν', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'ν', 'η', 'ξ', 'κ', 'β', 'μ', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            'μ', 'ξ', 'κ', 'λ', 'ν', NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+
+        Using the following characters:
+        */
+        private static final int GR_FINAL_SIGMA = '\u03C2'; // ς
+        private static final int GR_EPSILON = '\u03B5'; // ε
+        private static final int GR_RHO = '\u03C1'; // ρ
+        private static final int GR_TAU = '\u03C4'; // τ
+        private static final int GR_UPSILON = '\u03C5'; // υ
+        private static final int GR_THETA = '\u03B8'; // θ
+        private static final int GR_IOTA = '\u03B9'; // ι
+        private static final int GR_OMICRON = '\u03BF'; // ο
+        private static final int GR_PI = '\u03C0'; // π
+        private static final int GR_ALPHA = '\u03B1'; // α
+        private static final int GR_SIGMA = '\u03C3'; // σ
+        private static final int GR_DELTA = '\u03B4'; // δ
+        private static final int GR_PHI = '\u03C6'; // φ
+        private static final int GR_GAMMA = '\u03B3'; // γ
+        private static final int GR_ETA = '\u03B7'; // η
+        private static final int GR_XI = '\u03BE'; // ξ
+        private static final int GR_KAPPA = '\u03BA'; // κ
+        private static final int GR_LAMDA = '\u03BB'; // λ
+        private static final int GR_ZETA = '\u03B6'; // ζ
+        private static final int GR_CHI = '\u03C7'; // χ
+        private static final int GR_PSI = '\u03C8'; // ψ
+        private static final int GR_OMEGA = '\u03C9'; // ω
+        private static final int GR_BETA = '\u03B2'; // β
+        private static final int GR_NU = '\u03BD'; // ν
+        private static final int GR_MU = '\u03BC'; // μ
+        final static int[] PROXIMITY = {
+            // Proximity for row 1. This must have exactly ROW_SIZE entries for each letter,
+            // and exactly PROXIMITY_GRID_WIDTH letters for a row. Pad with NUL's.
+            // The number of rows must be exactly PROXIMITY_GRID_HEIGHT.
+            GR_FINAL_SIGMA, GR_EPSILON, GR_ALPHA, GR_SIGMA, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_EPSILON, GR_FINAL_SIGMA, GR_RHO, GR_SIGMA, GR_DELTA, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_RHO, GR_EPSILON, GR_TAU, GR_DELTA, GR_PHI, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_TAU, GR_RHO, GR_UPSILON, GR_PHI, GR_GAMMA, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_UPSILON, GR_TAU, GR_THETA, GR_GAMMA, GR_ETA, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_THETA, GR_UPSILON, GR_IOTA, GR_ETA, GR_XI, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_IOTA, GR_THETA, GR_OMICRON, GR_XI, GR_KAPPA, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_OMICRON, GR_IOTA, GR_PI, GR_KAPPA, GR_LAMDA, NUL, NUL, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_PI, GR_OMICRON, GR_LAMDA, NUL, NUL, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+
+            GR_ALPHA, GR_FINAL_SIGMA, GR_SIGMA, GR_ZETA, NUL, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_SIGMA, GR_FINAL_SIGMA, GR_EPSILON, GR_ALPHA, GR_DELTA, GR_ZETA, GR_CHI, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_DELTA, GR_EPSILON, GR_RHO, GR_SIGMA, GR_PHI, GR_ZETA, GR_CHI, GR_PSI,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_PHI, GR_RHO, GR_TAU, GR_DELTA, GR_GAMMA, GR_CHI, GR_PSI, GR_OMEGA,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_GAMMA, GR_TAU, GR_UPSILON, GR_PHI, GR_ETA, GR_PSI, GR_OMEGA, GR_BETA,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_ETA, GR_UPSILON, GR_THETA, GR_GAMMA, GR_XI, GR_OMEGA, GR_BETA, GR_NU,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_XI, GR_THETA, GR_IOTA, GR_ETA, GR_KAPPA, GR_BETA, GR_NU, GR_MU,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_KAPPA, GR_IOTA, GR_OMICRON, GR_XI, GR_LAMDA, GR_NU, GR_MU, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_LAMDA, GR_OMICRON, GR_PI, GR_KAPPA, GR_MU, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+
+            GR_ZETA, GR_ALPHA, GR_SIGMA, GR_DELTA, GR_CHI, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_CHI, GR_SIGMA, GR_DELTA, GR_PHI, GR_ZETA, GR_PSI, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_PSI, GR_DELTA, GR_PHI, GR_GAMMA, GR_CHI, GR_OMEGA, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_OMEGA, GR_PHI, GR_GAMMA, GR_ETA, GR_PSI, GR_BETA, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_BETA, GR_GAMMA, GR_ETA, GR_XI, GR_OMEGA, GR_NU, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_NU, GR_ETA, GR_XI, GR_KAPPA, GR_BETA, GR_MU, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            GR_MU, GR_XI, GR_KAPPA, GR_LAMDA, GR_NU, NUL, NUL, NUL,
+                    NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
+            NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
             NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL,
         };
@@ -183,6 +433,8 @@
                 return Latin.PROXIMITY;
             case AndroidSpellCheckerService.SCRIPT_CYRILLIC:
                 return Cyrillic.PROXIMITY;
+            case AndroidSpellCheckerService.SCRIPT_GREEK:
+                return Greek.PROXIMITY;
             default:
                 throw new RuntimeException("Wrong script supplied: " + script);
         }
@@ -194,6 +446,8 @@
                 return Latin.getIndexOf(codePoint);
             case AndroidSpellCheckerService.SCRIPT_CYRILLIC:
                 return Cyrillic.getIndexOf(codePoint);
+            case AndroidSpellCheckerService.SCRIPT_GREEK:
+                return Greek.getIndexOf(codePoint);
             default:
                 throw new RuntimeException("Wrong script supplied: " + script);
         }
diff --git a/java/src/com/android/inputmethod/research/FixedLogBuffer.java b/java/src/com/android/inputmethod/research/FixedLogBuffer.java
index f3302d8..7771119 100644
--- a/java/src/com/android/inputmethod/research/FixedLogBuffer.java
+++ b/java/src/com/android/inputmethod/research/FixedLogBuffer.java
@@ -72,7 +72,16 @@
         mNumActualWords++; // Must be a word, or we wouldn't be here.
     }
 
-    private void shiftOutThroughFirstWord() {
+    @Override
+    public LogUnit unshiftIn() {
+        final LogUnit logUnit = super.unshiftIn();
+        if (logUnit != null && logUnit.hasWord()) {
+            mNumActualWords--;
+        }
+        return logUnit;
+    }
+
+    public void shiftOutThroughFirstWord() {
         final LinkedList<LogUnit> logUnits = getLogUnits();
         while (!logUnits.isEmpty()) {
             final LogUnit logUnit = logUnits.removeFirst();
diff --git a/java/src/com/android/inputmethod/research/LogBuffer.java b/java/src/com/android/inputmethod/research/LogBuffer.java
index 14e8d08..9d095f8 100644
--- a/java/src/com/android/inputmethod/research/LogBuffer.java
+++ b/java/src/com/android/inputmethod/research/LogBuffer.java
@@ -46,6 +46,20 @@
         mLogUnits.add(logUnit);
     }
 
+    public LogUnit unshiftIn() {
+        if (mLogUnits.isEmpty()) {
+            return null;
+        }
+        return mLogUnits.removeLast();
+    }
+
+    public LogUnit peekLastLogUnit() {
+        if (mLogUnits.isEmpty()) {
+            return null;
+        }
+        return mLogUnits.peekLast();
+    }
+
     public boolean isEmpty() {
         return mLogUnits.isEmpty();
     }
diff --git a/java/src/com/android/inputmethod/research/LogUnit.java b/java/src/com/android/inputmethod/research/LogUnit.java
index bcb144f..cfba289 100644
--- a/java/src/com/android/inputmethod/research/LogUnit.java
+++ b/java/src/com/android/inputmethod/research/LogUnit.java
@@ -114,24 +114,37 @@
             debugStringWriter = null;
             debugJsonWriter = null;
         }
-        final int size = mLogStatementList.size();
         // Write out any logStatement that passes the privacy filter.
-        for (int i = 0; i < size; i++) {
-            final LogStatement logStatement = mLogStatementList.get(i);
-            if (!isIncludingPrivateData && logStatement.mIsPotentiallyPrivate) {
-                continue;
+        final int size = mLogStatementList.size();
+        if (size != 0) {
+            // Note that jsonWriter is only set to a non-null value if the logUnit start text is
+            // output and at least one logStatement is output.
+            JsonWriter jsonWriter = null;
+            for (int i = 0; i < size; i++) {
+                final LogStatement logStatement = mLogStatementList.get(i);
+                if (!isIncludingPrivateData && logStatement.mIsPotentiallyPrivate) {
+                    continue;
+                }
+                if (mIsPartOfMegaword && logStatement.mIsPotentiallyRevealing) {
+                    continue;
+                }
+                // Only retrieve the jsonWriter if we need to.  If we don't get this far, then
+                // researchLog.getValidJsonWriterLocked() will not ever be called, and the file
+                // will not have been opened for writing.
+                if (jsonWriter == null) {
+                    jsonWriter = researchLog.getValidJsonWriterLocked();
+                    outputLogUnitStart(jsonWriter, isIncludingPrivateData);
+                }
+                outputLogStatementToLocked(jsonWriter, mLogStatementList.get(i), mValuesList.get(i),
+                        mTimeList.get(i));
+                if (DEBUG) {
+                    outputLogStatementToLocked(debugJsonWriter, mLogStatementList.get(i),
+                            mValuesList.get(i), mTimeList.get(i));
+                }
             }
-            if (mIsPartOfMegaword && logStatement.mIsPotentiallyRevealing) {
-                continue;
-            }
-            // Only retrieve the jsonWriter if we need to.  If we don't get this far, then
-            // researchLog.getValidJsonWriter() will not open the file for writing.
-            final JsonWriter jsonWriter = researchLog.getValidJsonWriterLocked();
-            outputLogStatementToLocked(jsonWriter, mLogStatementList.get(i), mValuesList.get(i),
-                    mTimeList.get(i));
-            if (DEBUG) {
-                outputLogStatementToLocked(debugJsonWriter, mLogStatementList.get(i),
-                        mValuesList.get(i), mTimeList.get(i));
+            if (jsonWriter != null) {
+                // We must have called logUnitStart earlier, so emit a logUnitStop.
+                outputLogUnitStop(jsonWriter, isIncludingPrivateData);
             }
         }
         if (DEBUG) {
@@ -152,6 +165,38 @@
     private static final String CURRENT_TIME_KEY = "_ct";
     private static final String UPTIME_KEY = "_ut";
     private static final String EVENT_TYPE_KEY = "_ty";
+    private static final String WORD_KEY = "_wo";
+    private static final String LOG_UNIT_BEGIN_KEY = "logUnitStart";
+    private static final String LOG_UNIT_END_KEY = "logUnitEnd";
+
+    private void outputLogUnitStart(final JsonWriter jsonWriter,
+            final boolean isIncludingPrivateData) {
+        try {
+            jsonWriter.beginObject();
+            jsonWriter.name(CURRENT_TIME_KEY).value(System.currentTimeMillis());
+            if (isIncludingPrivateData) {
+                jsonWriter.name(WORD_KEY).value(getWord());
+            }
+            jsonWriter.name(EVENT_TYPE_KEY).value(LOG_UNIT_BEGIN_KEY);
+            jsonWriter.endObject();
+        } catch (IOException e) {
+            e.printStackTrace();
+            Log.w(TAG, "Error in JsonWriter; cannot write LogUnitStart");
+        }
+    }
+
+    private void outputLogUnitStop(final JsonWriter jsonWriter,
+            final boolean isIncludingPrivateData) {
+        try {
+            jsonWriter.beginObject();
+            jsonWriter.name(CURRENT_TIME_KEY).value(System.currentTimeMillis());
+            jsonWriter.name(EVENT_TYPE_KEY).value(LOG_UNIT_END_KEY);
+            jsonWriter.endObject();
+        } catch (IOException e) {
+            e.printStackTrace();
+            Log.w(TAG, "Error in JsonWriter; cannot write LogUnitStop");
+        }
+    }
 
     /**
      * Write the logStatement and its contents out through jsonWriter.
@@ -240,6 +285,7 @@
     public LogUnit splitByTime(final long maxTime) {
         // Assume that mTimeList is in sorted order.
         final int length = mTimeList.size();
+        // TODO: find time by binary search, e.g. using Collections#binarySearch()
         for (int index = 0; index < length; index++) {
             if (mTimeList.get(index) > maxTime) {
                 final List<LogStatement> laterLogStatements =
@@ -267,4 +313,13 @@
         }
         return new LogUnit();
     }
+
+    public void append(final LogUnit logUnit) {
+        mLogStatementList.addAll(logUnit.mLogStatementList);
+        mValuesList.addAll(logUnit.mValuesList);
+        mTimeList.addAll(logUnit.mTimeList);
+        mWord = null;
+        mMayContainDigit = mMayContainDigit || logUnit.mMayContainDigit;
+        mIsPartOfMegaword = false;
+    }
 }
diff --git a/java/src/com/android/inputmethod/research/MainLogBuffer.java b/java/src/com/android/inputmethod/research/MainLogBuffer.java
index bec21d7..a8f255a 100644
--- a/java/src/com/android/inputmethod/research/MainLogBuffer.java
+++ b/java/src/com/android/inputmethod/research/MainLogBuffer.java
@@ -26,18 +26,42 @@
 import java.util.Random;
 
 /**
- * Provide a log buffer of fixed length that enforces privacy restrictions.
+ * MainLogBuffer is a FixedLogBuffer that tracks the state of LogUnits to make privacy guarantees.
  *
- * The privacy restrictions include making sure that no numbers are logged, that all logged words
- * are in the dictionary, and that words are recorded infrequently enough that the user's meaning
- * cannot be easily determined.
+ * There are three forms of privacy protection: 1) only words in the main dictionary are allowed to
+ * be logged in enough detail to determine their contents, 2) only a subset of words are logged
+ * in detail, such as 10%, and 3) no numbers are logged.
+ *
+ * This class maintains a list of LogUnits, each corresponding to a word.  As the user completes
+ * words, they are added here.  But if the user backs up over their current word to edit a word
+ * entered earlier, then it is pulled out of this LogBuffer, changes are then added to the end of
+ * the LogUnit, and it is pushed back in here when the user is done.  Because words may be pulled
+ * back out even after they are pushed in, we must not publish the contents of this LogBuffer too
+ * quickly.  However, we cannot let the contents pile up either, or it will limit the editing that
+ * a user can perform.
+ *
+ * To balance these requirements (keep history so user can edit, flush history so it does not pile
+ * up), the LogBuffer is considered "complete" when the user has entered enough words to form an
+ * n-gram, followed by enough additional non-detailed words (that are in the 90%, as per above).
+ * Once complete, the n-gram may be published to flash storage (via the ResearchLog class).
+ * However, the additional non-detailed words are retained, in case the user backspaces to edit
+ * them.  The MainLogBuffer then continues to add words, publishing individual non-detailed words
+ * as new words arrive.  After enough non-detailed words have been pushed out to account for the
+ * 90% between words, the words at the front of the LogBuffer can be published as an n-gram again.
+ *
+ * If the words that would form the valid n-gram are not in the dictionary, then words are pushed
+ * through the LogBuffer one at a time until an n-gram is found that is entirely composed of
+ * dictionary words.
+ *
+ * If the user closes a session, then the entire LogBuffer is flushed, publishing any embedded
+ * n-gram containing dictionary words.
  */
 public class MainLogBuffer extends FixedLogBuffer {
     private static final String TAG = MainLogBuffer.class.getSimpleName();
     private static final boolean DEBUG = false && ProductionFlag.IS_EXPERIMENTAL_DEBUG;
 
     // The size of the n-grams logged.  E.g. N_GRAM_SIZE = 2 means to sample bigrams.
-    private static final int N_GRAM_SIZE = 2;
+    public static final int N_GRAM_SIZE = 2;
     // The number of words between n-grams to omit from the log.  If debugging, record 50% of all
     // words.  Otherwise, only record 10%.
     private static final int DEFAULT_NUMBER_OF_WORDS_BETWEEN_SAMPLES =
@@ -46,49 +70,31 @@
     private final ResearchLog mResearchLog;
     private Suggest mSuggest;
 
-    // The minimum periodicity with which n-grams can be sampled.  E.g. mWinWordPeriod is 10 if
-    // every 10th bigram is sampled, i.e., words 1-8 are not, but the bigram at words 9 and 10, etc.
-    // for 11-18, and the bigram at words 19 and 20.  If an n-gram is not safe (e.g. it  contains a
-    // number in the middle or an out-of-vocabulary word), then sampling is delayed until a safe
-    // n-gram does appear.
-    /* package for test */ int mMinWordPeriod;
+    /* package for test */ int mNumWordsBetweenNGrams;
 
     // Counter for words left to suppress before an n-gram can be sampled.  Reset to mMinWordPeriod
     // after a sample is taken.
-    /* package for test */ int mWordsUntilSafeToSample;
+    /* package for test */ int mNumWordsUntilSafeToSample;
 
     public MainLogBuffer(final ResearchLog researchLog) {
-        super(N_GRAM_SIZE);
+        super(N_GRAM_SIZE + DEFAULT_NUMBER_OF_WORDS_BETWEEN_SAMPLES);
         mResearchLog = researchLog;
-        mMinWordPeriod = DEFAULT_NUMBER_OF_WORDS_BETWEEN_SAMPLES + N_GRAM_SIZE;
+        mNumWordsBetweenNGrams = DEFAULT_NUMBER_OF_WORDS_BETWEEN_SAMPLES;
         final Random random = new Random();
-        mWordsUntilSafeToSample = random.nextInt(mMinWordPeriod);
+        mNumWordsUntilSafeToSample = DEBUG ? 0 : random.nextInt(mNumWordsBetweenNGrams + 1);
     }
 
     public void setSuggest(final Suggest suggest) {
         mSuggest = suggest;
     }
 
-    @Override
-    public void shiftIn(final LogUnit newLogUnit) {
-        super.shiftIn(newLogUnit);
-        if (newLogUnit.hasWord()) {
-            if (mWordsUntilSafeToSample > 0) {
-                mWordsUntilSafeToSample--;
-            }
-        }
-        if (DEBUG) {
-            Log.d(TAG, "shiftedIn " + (newLogUnit.hasWord() ? newLogUnit.getWord() : ""));
-        }
-    }
-
     public void resetWordCounter() {
-        mWordsUntilSafeToSample = mMinWordPeriod;
+        mNumWordsUntilSafeToSample = mNumWordsBetweenNGrams;
     }
 
     /**
-     * Determines whether the content of the MainLogBuffer can be safely uploaded in its complete
-     * form and still protect the user's privacy.
+     * Determines whether uploading the n words at the front the MainLogBuffer will not violate
+     * user privacy.
      *
      * The size of the MainLogBuffer is just enough to hold one n-gram, its corrections, and any
      * non-character data that is typed between words.  The decision about privacy is made based on
@@ -97,10 +103,10 @@
      * the screen orientation and other characteristics about the device can be uploaded without
      * revealing much about the user.
      */
-    public boolean isSafeToLog() {
+    public boolean isNGramSafe() {
         // Check that we are not sampling too frequently.  Having sampled recently might disclose
         // too much of the user's intended meaning.
-        if (mWordsUntilSafeToSample > 0) {
+        if (mNumWordsUntilSafeToSample > 0) {
             return false;
         }
         if (mSuggest == null || !mSuggest.hasMainDictionary()) {
@@ -119,7 +125,8 @@
         // complete buffer contents in detail.
         final LinkedList<LogUnit> logUnits = getLogUnits();
         final int length = logUnits.size();
-        for (int i = 0; i < length; i++) {
+        int wordsNeeded = N_GRAM_SIZE;
+        for (int i = 0; i < length && wordsNeeded > 0; i++) {
             final LogUnit logUnit = logUnits.get(i);
             final String word = logUnit.getWord();
             if (word == null) {
@@ -142,10 +149,34 @@
         return true;
     }
 
+    public boolean isNGramComplete() {
+        final LinkedList<LogUnit> logUnits = getLogUnits();
+        final int length = logUnits.size();
+        int wordsNeeded = N_GRAM_SIZE;
+        for (int i = 0; i < length && wordsNeeded > 0; i++) {
+            final LogUnit logUnit = logUnits.get(i);
+            final String word = logUnit.getWord();
+            if (word != null) {
+                wordsNeeded--;
+            }
+        }
+        return wordsNeeded == 0;
+    }
+
     @Override
     protected void onShiftOut(final LogUnit logUnit) {
         if (mResearchLog != null) {
-            mResearchLog.publish(logUnit, false /* isIncludingPrivateData */);
+            mResearchLog.publish(logUnit,
+                    ResearchLogger.IS_LOGGING_EVERYTHING /* isIncludingPrivateData */);
+        }
+        if (logUnit.hasWord()) {
+            if (mNumWordsUntilSafeToSample > 0) {
+                mNumWordsUntilSafeToSample--;
+                Log.d(TAG, "wordsUntilSafeToSample now at " + mNumWordsUntilSafeToSample);
+            }
+        }
+        if (DEBUG) {
+            Log.d(TAG, "shiftedOut " + (logUnit.hasWord() ? logUnit.getWord() : ""));
         }
     }
 }
diff --git a/java/src/com/android/inputmethod/research/ResearchLog.java b/java/src/com/android/inputmethod/research/ResearchLog.java
index a6b1b88..5edb46e 100644
--- a/java/src/com/android/inputmethod/research/ResearchLog.java
+++ b/java/src/com/android/inputmethod/research/ResearchLog.java
@@ -16,6 +16,7 @@
 
 package com.android.inputmethod.research;
 
+import android.content.Context;
 import android.util.JsonWriter;
 import android.util.Log;
 
@@ -23,7 +24,7 @@
 
 import java.io.BufferedWriter;
 import java.io.File;
-import java.io.FileWriter;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
@@ -50,6 +51,8 @@
 
     /* package */ final ScheduledExecutorService mExecutor;
     /* package */ final File mFile;
+    private final Context mContext;
+
     private JsonWriter mJsonWriter = NULL_JSON_WRITER;
     // true if at least one byte of data has been written out to the log file.  This must be
     // remembered because JsonWriter requires that calls matching calls to beginObject and
@@ -78,12 +81,13 @@
         }
     }
 
-    public ResearchLog(final File outputFile) {
+    public ResearchLog(final File outputFile, Context context) {
         if (outputFile == null) {
             throw new IllegalArgumentException();
         }
         mExecutor = Executors.newSingleThreadScheduledExecutor();
         mFile = outputFile;
+        mContext = context;
     }
 
     public synchronized void close(final Runnable onClosed) {
@@ -193,6 +197,9 @@
             });
         } catch (RejectedExecutionException e) {
             // TODO: Add code to record loss of data, and report.
+            if (DEBUG) {
+                Log.d(TAG, "ResearchLog.publish() rejecting scheduled execution");
+            }
         }
     }
 
@@ -203,7 +210,9 @@
     public JsonWriter getValidJsonWriterLocked() {
         try {
             if (mJsonWriter == NULL_JSON_WRITER) {
-                mJsonWriter = new JsonWriter(new BufferedWriter(new FileWriter(mFile)));
+                final FileOutputStream fos =
+                        mContext.openFileOutput(mFile.getName(), Context.MODE_PRIVATE);
+                mJsonWriter = new JsonWriter(new BufferedWriter(new OutputStreamWriter(fos)));
                 mJsonWriter.beginArray();
                 mHasWrittenData = true;
             }
diff --git a/java/src/com/android/inputmethod/research/ResearchLogger.java b/java/src/com/android/inputmethod/research/ResearchLogger.java
index b1484e6..f4249a0 100644
--- a/java/src/com/android/inputmethod/research/ResearchLogger.java
+++ b/java/src/com/android/inputmethod/research/ResearchLogger.java
@@ -85,7 +85,7 @@
     private static final String TAG = ResearchLogger.class.getSimpleName();
     private static final boolean DEBUG = false && ProductionFlag.IS_EXPERIMENTAL_DEBUG;
     // Whether all n-grams should be logged.  true will disclose private info.
-    private static final boolean LOG_EVERYTHING = false
+    public static final boolean IS_LOGGING_EVERYTHING = false
             && ProductionFlag.IS_EXPERIMENTAL_DEBUG;
     // Whether the TextView contents are logged at the end of the session.  true will disclose
     // private info.
@@ -105,7 +105,7 @@
     private static final boolean IS_SHOWING_INDICATOR = true;
     // Change the default indicator to something very visible.  Currently two red vertical bars on
     // either side of they keyboard.
-    private static final boolean IS_SHOWING_INDICATOR_CLEARLY = false || LOG_EVERYTHING;
+    private static final boolean IS_SHOWING_INDICATOR_CLEARLY = false || IS_LOGGING_EVERYTHING;
     public static final int FEEDBACK_WORD_BUFFER_SIZE = 5;
 
     // constants related to specific log points
@@ -324,11 +324,22 @@
         sIsLogging = enableLogging;
     }
 
+    private static int sLogFileCounter = 0;
+
     private File createLogFile(File filesDir) {
         final StringBuilder sb = new StringBuilder();
         sb.append(FILENAME_PREFIX).append('-');
         sb.append(mUUIDString).append('-');
-        sb.append(TIMESTAMP_DATEFORMAT.format(new Date()));
+        sb.append(TIMESTAMP_DATEFORMAT.format(new Date())).append('-');
+        // Sometimes logFiles are created within milliseconds of each other.  Append a counter to
+        // separate these.
+        if (sLogFileCounter < Integer.MAX_VALUE) {
+            sLogFileCounter++;
+        } else {
+            // Wrap the counter, in the unlikely event of overflow.
+            sLogFileCounter = 0;
+        }
+        sb.append(sLogFileCounter);
         sb.append(FILENAME_SUFFIX);
         return new File(filesDir, sb.toString());
     }
@@ -374,12 +385,12 @@
             return;
         }
         if (mMainLogBuffer == null) {
-            mMainResearchLog = new ResearchLog(createLogFile(mFilesDir));
+            mMainResearchLog = new ResearchLog(createLogFile(mFilesDir), mLatinIME);
             mMainLogBuffer = new MainLogBuffer(mMainResearchLog);
             mMainLogBuffer.setSuggest(mSuggest);
         }
         if (mFeedbackLogBuffer == null) {
-            mFeedbackLog = new ResearchLog(createLogFile(mFilesDir));
+            mFeedbackLog = new ResearchLog(createLogFile(mFilesDir), mLatinIME);
             // LogBuffer is one more than FEEDBACK_WORD_BUFFER_SIZE, because it must also hold
             // the feedback LogUnit itself.
             mFeedbackLogBuffer = new FixedLogBuffer(FEEDBACK_WORD_BUFFER_SIZE + 1);
@@ -390,11 +401,20 @@
         if (DEBUG) {
             Log.d(TAG, "stop called");
         }
+        // Commit mCurrentLogUnit before closing.
         commitCurrentLogUnit();
 
         if (mMainLogBuffer != null) {
-            publishLogBuffer(mMainLogBuffer, mMainResearchLog,
-                    LOG_EVERYTHING /* isIncludingPrivateData */);
+            while (!mMainLogBuffer.isEmpty()) {
+                if ((mMainLogBuffer.isNGramSafe() || IS_LOGGING_EVERYTHING) &&
+                        mMainResearchLog != null) {
+                    publishLogBuffer(mMainLogBuffer, mMainResearchLog,
+                            true /* isIncludingPrivateData */);
+                    mMainLogBuffer.resetWordCounter();
+                } else {
+                    mMainLogBuffer.shiftOutThroughFirstWord();
+                }
+            }
             mMainResearchLog.close(null /* callback */);
             mMainLogBuffer = null;
         }
@@ -590,7 +610,7 @@
                 uploadNow();
             }
         });
-        mFeedbackLog = new ResearchLog(createLogFile(mFilesDir));
+        mFeedbackLog = new ResearchLog(createLogFile(mFilesDir), mLatinIME);
     }
 
     public void uploadNow() {
@@ -676,11 +696,17 @@
     /**
      * Buffer a research log event, flagging it as privacy-sensitive.
      */
-    private synchronized void enqueueEvent(LogStatement logStatement, Object... values) {
+    private synchronized void enqueueEvent(final LogStatement logStatement,
+            final Object... values) {
+        enqueueEvent(mCurrentLogUnit, logStatement, values);
+    }
+
+    private synchronized void enqueueEvent(final LogUnit logUnit, final LogStatement logStatement,
+            final Object... values) {
         assert values.length == logStatement.mKeys.length;
-        if (isAllowedToLog()) {
+        if (isAllowedToLog() && logUnit != null) {
             final long time = SystemClock.uptimeMillis();
-            mCurrentLogUnit.addLogStatement(logStatement, time, values);
+            logUnit.addLogStatement(logStatement, time, values);
         }
     }
 
@@ -695,17 +721,70 @@
         }
         if (!mCurrentLogUnit.isEmpty()) {
             if (mMainLogBuffer != null) {
-                mMainLogBuffer.shiftIn(mCurrentLogUnit);
-                if ((mMainLogBuffer.isSafeToLog() || LOG_EVERYTHING) && mMainResearchLog != null) {
+                if ((mMainLogBuffer.isNGramSafe() || IS_LOGGING_EVERYTHING) &&
+                        mMainLogBuffer.isNGramComplete() &&
+                        mMainResearchLog != null) {
                     publishLogBuffer(mMainLogBuffer, mMainResearchLog,
                             true /* isIncludingPrivateData */);
                     mMainLogBuffer.resetWordCounter();
                 }
+                mMainLogBuffer.shiftIn(mCurrentLogUnit);
             }
             if (mFeedbackLogBuffer != null) {
                 mFeedbackLogBuffer.shiftIn(mCurrentLogUnit);
             }
             mCurrentLogUnit = new LogUnit();
+        } else {
+            if (DEBUG) {
+                Log.d(TAG, "Warning: tried to commit empty log unit.");
+            }
+        }
+    }
+
+    private static final LogStatement LOGSTATEMENT_UNCOMMIT_CURRENT_LOGUNIT =
+            new LogStatement("UncommitCurrentLogUnit", false, false);
+    public void uncommitCurrentLogUnit(final String expectedWord,
+            final boolean dumpCurrentLogUnit) {
+        // The user has deleted this word and returned to the previous.  Check that the word in the
+        // logUnit matches the expected word.  If so, restore the last log unit committed to be the
+        // current logUnit.  I.e., pull out the last LogUnit from all the LogBuffers, and make
+        // restore it to mCurrentLogUnit so the new edits are captured with the word.  Optionally
+        // dump the contents of mCurrentLogUnit (useful if they contain deletions of the next word
+        // that should not be reported to protect user privacy)
+        //
+        // Note that we don't use mLastLogUnit here, because it only goes one word back and is only
+        // needed for reverts, which only happen one back.
+        if (mMainLogBuffer == null) {
+            return;
+        }
+        final LogUnit oldLogUnit = mMainLogBuffer.peekLastLogUnit();
+
+        // Check that expected word matches.
+        if (oldLogUnit != null) {
+            final String oldLogUnitWord = oldLogUnit.getWord();
+            if (!oldLogUnitWord.equals(expectedWord)) {
+                return;
+            }
+        }
+
+        // Uncommit, merging if necessary.
+        mMainLogBuffer.unshiftIn();
+        if (oldLogUnit != null && !dumpCurrentLogUnit) {
+            oldLogUnit.append(mCurrentLogUnit);
+            mSavedDownEventTime = Long.MAX_VALUE;
+        }
+        if (oldLogUnit == null) {
+            mCurrentLogUnit = new LogUnit();
+        } else {
+            mCurrentLogUnit = oldLogUnit;
+        }
+        if (mFeedbackLogBuffer != null) {
+            mFeedbackLogBuffer.unshiftIn();
+        }
+        enqueueEvent(LOGSTATEMENT_UNCOMMIT_CURRENT_LOGUNIT);
+        if (DEBUG) {
+            Log.d(TAG, "uncommitCurrentLogUnit (dump=" + dumpCurrentLogUnit + ") back to "
+                    + (mCurrentLogUnit.hasWord() ? ": '" + mCurrentLogUnit.getWord() + "'" : ""));
         }
     }
 
@@ -721,12 +800,16 @@
                 isIncludingPrivateData);
         researchLog.publish(openingLogUnit, true /* isIncludingPrivateData */);
         LogUnit logUnit;
-        while ((logUnit = logBuffer.shiftOut()) != null) {
+        int numWordsToPublish = MainLogBuffer.N_GRAM_SIZE;
+        while ((logUnit = logBuffer.shiftOut()) != null && numWordsToPublish > 0) {
             if (DEBUG) {
                 Log.d(TAG, "publishLogBuffer: " + (logUnit.hasWord() ? logUnit.getWord()
                         : "<wordless>"));
             }
             researchLog.publish(logUnit, isIncludingPrivateData);
+            if (logUnit.getWord() != null) {
+                numWordsToPublish--;
+            }
         }
         final LogUnit closingLogUnit = new LogUnit();
         closingLogUnit.addLogStatement(LOGSTATEMENT_LOG_SEGMENT_CLOSING,
@@ -751,24 +834,30 @@
      * After this operation completes, mCurrentLogUnit will hold any logStatements that happened
      * after maxTime.
      */
-    private static final LogStatement LOGSTATEMENT_COMMIT_RECORD_SPLIT_WORDS =
-            new LogStatement("recordSplitWords", true, false);
-    /* package for test */ void commitCurrentLogUnitAsWord(final String word, final long maxTime) {
+    /* package for test */ void commitCurrentLogUnitAsWord(final String word, final long maxTime,
+            final boolean isBatchMode) {
+        if (word == null) {
+            return;
+        }
         final Dictionary dictionary = getDictionary();
-        if (word != null && word.length() > 0 && hasLetters(word)) {
+        if (word.length() > 0 && hasLetters(word)) {
             mCurrentLogUnit.setWord(word);
             final boolean isDictionaryWord = dictionary != null
                     && dictionary.isValidWord(word);
             mStatistics.recordWordEntered(isDictionaryWord);
         }
         final LogUnit newLogUnit = mCurrentLogUnit.splitByTime(maxTime);
-        enqueueCommitText(word);
+        enqueueCommitText(word, isBatchMode);
         commitCurrentLogUnit();
         mCurrentLogUnit = newLogUnit;
     }
 
-    public void onWordFinished(final String word) {
-        commitCurrentLogUnitAsWord(word, mSavedDownEventTime);
+    private void setSavedDownEventTime(final long time) {
+        mSavedDownEventTime = time;
+    }
+
+    public void onWordFinished(final String word, final boolean isBatchMode) {
+        commitCurrentLogUnitAsWord(word, mSavedDownEventTime, isBatchMode);
         mSavedDownEventTime = Long.MAX_VALUE;
     }
 
@@ -863,7 +952,7 @@
                         Integer.toHexString(editorInfo.inputType),
                         Integer.toHexString(editorInfo.imeOptions), editorInfo.fieldId,
                         Build.DISPLAY, Build.MODEL, prefs, versionCode, versionName,
-                        OUTPUT_FORMAT_VERSION, LOG_EVERYTHING,
+                        OUTPUT_FORMAT_VERSION, IS_LOGGING_EVERYTHING,
                         ProductionFlag.IS_EXPERIMENTAL_DEBUG);
             } catch (NameNotFoundException e) {
                 e.printStackTrace();
@@ -916,7 +1005,7 @@
             if (action == MotionEvent.ACTION_DOWN) {
                 // Subtract 1 from eventTime so the down event is included in the later
                 // LogUnit, not the earlier (the test is for inequality).
-                researchLogger.mSavedDownEventTime = eventTime - 1;
+                researchLogger.setSavedDownEventTime(eventTime - 1);
             }
         }
     }
@@ -1060,9 +1149,9 @@
      *
      * SystemResponse: Raw text is added to the TextView.
      */
-    public static void latinIME_onTextInput(final String text) {
+    public static void latinIME_onTextInput(final String text, final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE);
+        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE, isBatchMode);
     }
 
     /**
@@ -1074,15 +1163,15 @@
             new LogStatement("LatinIMEPickSuggestionManually", true, false, "replacedWord", "index",
                     "suggestion", "x", "y");
     public static void latinIME_pickSuggestionManually(final String replacedWord,
-            final int index, final String suggestion) {
+            final int index, final String suggestion, final boolean isBatchMode) {
         final String scrubbedWord = scrubDigitsFromString(suggestion);
         final ResearchLogger researchLogger = getInstance();
         researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_PICKSUGGESTIONMANUALLY,
                 scrubDigitsFromString(replacedWord), index,
                 suggestion == null ? null : scrubbedWord, Constants.SUGGESTION_STRIP_COORDINATE,
                 Constants.SUGGESTION_STRIP_COORDINATE);
-        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE);
-        researchLogger.mStatistics.recordManualSuggestion();
+        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE, isBatchMode);
+        researchLogger.mStatistics.recordManualSuggestion(SystemClock.uptimeMillis());
     }
 
     /**
@@ -1092,20 +1181,21 @@
      */
     private static final LogStatement LOGSTATEMENT_LATINIME_PUNCTUATIONSUGGESTION =
             new LogStatement("LatinIMEPunctuationSuggestion", false, false, "index", "suggestion",
-                    "x", "y");
-    public static void latinIME_punctuationSuggestion(final int index, final String suggestion) {
+                    "x", "y", "isPrediction");
+    public static void latinIME_punctuationSuggestion(final int index, final String suggestion,
+            final boolean isBatchMode, final boolean isPrediction) {
         final ResearchLogger researchLogger = getInstance();
         researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_PUNCTUATIONSUGGESTION, index, suggestion,
-                Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE);
-        researchLogger.commitCurrentLogUnitAsWord(suggestion, Long.MAX_VALUE);
+                Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE,
+                isPrediction);
+        researchLogger.commitCurrentLogUnitAsWord(suggestion, Long.MAX_VALUE, isBatchMode);
     }
 
     /**
      * Log a call to LatinIME.sendKeyCodePoint().
      *
-     * SystemResponse: The IME is simulating a hardware keypress.  This happens for numbers; other
-     * input typically goes through RichInputConnection.setComposingText() and
-     * RichInputConnection.commitText().
+     * SystemResponse: The IME is inserting text into the TextView for numbers, fixed strings, or
+     * some other unusual mechanism.
      */
     private static final LogStatement LOGSTATEMENT_LATINIME_SENDKEYCODEPOINT =
             new LogStatement("LatinIMESendKeyCodePoint", true, false, "code");
@@ -1119,17 +1209,45 @@
     }
 
     /**
+     * Log a call to LatinIME.promotePhantomSpace().
+     *
+     * SystemResponse: The IME is inserting a real space in place of a phantom space.
+     */
+    private static final LogStatement LOGSTATEMENT_LATINIME_PROMOTEPHANTOMSPACE =
+            new LogStatement("LatinIMEPromotPhantomSpace", false, false);
+    public static void latinIME_promotePhantomSpace() {
+        final ResearchLogger researchLogger = getInstance();
+        final LogUnit logUnit;
+        if (researchLogger.mMainLogBuffer == null) {
+            logUnit = researchLogger.mCurrentLogUnit;
+        } else {
+            logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit();
+        }
+        researchLogger.enqueueEvent(logUnit, LOGSTATEMENT_LATINIME_PROMOTEPHANTOMSPACE);
+    }
+
+    /**
      * Log a call to LatinIME.swapSwapperAndSpace().
      *
      * SystemResponse: A symbol has been swapped with a space character.  E.g. punctuation may swap
      * if a soft space is inserted after a word.
      */
     private static final LogStatement LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE =
-            new LogStatement("LatinIMESwapSwapperAndSpace", false, false);
-    public static void latinIME_swapSwapperAndSpace(final String text) {
+            new LogStatement("LatinIMESwapSwapperAndSpace", false, false, "originalCharacters",
+                    "charactersAfterSwap");
+    public static void latinIME_swapSwapperAndSpace(final CharSequence originalCharacters,
+            final String charactersAfterSwap) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE);
-        researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE);
+        final LogUnit logUnit;
+        if (researchLogger.mMainLogBuffer == null) {
+            logUnit = null;
+        } else {
+            logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit();
+        }
+        if (logUnit != null) {
+            researchLogger.enqueueEvent(logUnit, LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE,
+                    originalCharacters, charactersAfterSwap);
+        }
     }
 
     /**
@@ -1137,9 +1255,10 @@
      *
      * SystemResponse: Two spaces have been replaced by period space.
      */
-    public static void latinIME_maybeDoubleSpacePeriod(final String text) {
+    public static void latinIME_maybeDoubleSpacePeriod(final String text,
+            final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE);
+        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE, isBatchMode);
     }
 
     /**
@@ -1169,8 +1288,9 @@
     public static void mainKeyboardView_setKeyboard(final Keyboard keyboard) {
         final KeyboardId kid = keyboard.mId;
         final boolean isPasswordView = kid.passwordInput();
-        getInstance().setIsPasswordView(isPasswordView);
-        getInstance().enqueueEvent(LOGSTATEMENT_MAINKEYBOARDVIEW_SETKEYBOARD,
+        final ResearchLogger researchLogger = getInstance();
+        researchLogger.setIsPasswordView(isPasswordView);
+        researchLogger.enqueueEvent(LOGSTATEMENT_MAINKEYBOARDVIEW_SETKEYBOARD,
                 KeyboardId.elementIdToName(kid.mElementId),
                 kid.mLocale + ":" + kid.mSubtype.getExtraValueOf(KEYBOARD_LAYOUT_SET),
                 kid.mOrientation, kid.mWidth, KeyboardId.modeName(kid.mMode), kid.imeAction(),
@@ -1189,14 +1309,28 @@
      */
     private static final LogStatement LOGSTATEMENT_LATINIME_REVERTCOMMIT =
             new LogStatement("LatinIMERevertCommit", true, false, "committedWord",
-                    "originallyTypedWord");
+                    "originallyTypedWord", "separatorString");
     public static void latinIME_revertCommit(final String committedWord,
-            final String originallyTypedWord) {
+            final String originallyTypedWord, final boolean isBatchMode,
+            final String separatorString) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_REVERTCOMMIT, committedWord,
-                originallyTypedWord);
-        researchLogger.mStatistics.recordRevertCommit();
-        researchLogger.commitCurrentLogUnitAsWord(originallyTypedWord, Long.MAX_VALUE);
+        // TODO: Verify that mCurrentLogUnit has been restored and contains the reverted word.
+        final LogUnit logUnit;
+        if (researchLogger.mMainLogBuffer == null) {
+            logUnit = null;
+        } else {
+            logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit();
+        }
+        if (originallyTypedWord.length() > 0 && hasLetters(originallyTypedWord)) {
+            if (logUnit != null) {
+                logUnit.setWord(originallyTypedWord);
+            }
+        }
+        researchLogger.enqueueEvent(logUnit != null ? logUnit : researchLogger.mCurrentLogUnit,
+                LOGSTATEMENT_LATINIME_REVERTCOMMIT, committedWord, originallyTypedWord,
+                separatorString);
+        researchLogger.mStatistics.recordRevertCommit(SystemClock.uptimeMillis());
+        researchLogger.commitCurrentLogUnitAsWord(originallyTypedWord, Long.MAX_VALUE, isBatchMode);
     }
 
     /**
@@ -1295,9 +1429,10 @@
      *
      * SystemResponse: The IME has reverted ". ", which had previously replaced two typed spaces.
      */
-    public static void richInputConnection_revertDoubleSpacePeriod(final String doubleSpace) {
-        final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(doubleSpace, Long.MAX_VALUE);
+    private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTION_REVERTDOUBLESPACEPERIOD =
+            new LogStatement("RichInputConnectionRevertDoubleSpacePeriod", false, false);
+    public static void richInputConnection_revertDoubleSpacePeriod() {
+        getInstance().enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTION_REVERTDOUBLESPACEPERIOD);
     }
 
     /**
@@ -1305,9 +1440,10 @@
      *
      * SystemResponse: The IME has reverted a punctuation swap.
      */
-    public static void richInputConnection_revertSwapPunctuation(final String text) {
-        final ResearchLogger researchLogger = getInstance();
-        researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE);
+    private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTION_REVERTSWAPPUNCTUATION =
+            new LogStatement("RichInputConnectionRevertSwapPunctuation", false, false);
+    public static void richInputConnection_revertSwapPunctuation() {
+        getInstance().enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTION_REVERTSWAPPUNCTUATION);
     }
 
     /**
@@ -1317,16 +1453,24 @@
      * text input to another word that the user more likely desired to type.
      */
     private static final LogStatement LOGSTATEMENT_LATINIME_COMMITCURRENTAUTOCORRECTION =
-            new LogStatement("LatinIMECommitCurrentAutoCorrection", true, false, "typedWord",
+            new LogStatement("LatinIMECommitCurrentAutoCorrection", true, true, "typedWord",
                     "autoCorrection", "separatorString");
     public static void latinIme_commitCurrentAutoCorrection(final String typedWord,
-            final String autoCorrection, final String separatorString) {
+            final String autoCorrection, final String separatorString, final boolean isBatchMode) {
         final String scrubbedTypedWord = scrubDigitsFromString(typedWord);
         final String scrubbedAutoCorrection = scrubDigitsFromString(autoCorrection);
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_COMMITCURRENTAUTOCORRECTION,
+        researchLogger.commitCurrentLogUnitAsWord(scrubbedAutoCorrection, Long.MAX_VALUE,
+                isBatchMode);
+
+        // Add the autocorrection logStatement at the end of the logUnit for the committed word.
+        // We have to do this after calling commitCurrentLogUnitAsWord, because it may split the
+        // current logUnit, and then we have to peek to get the logUnit reference back.
+        final LogUnit logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit();
+        // TODO: Add test to confirm that the commitCurrentAutoCorrection log statement should
+        // always be added to logUnit (if non-null) and not mCurrentLogUnit.
+        researchLogger.enqueueEvent(logUnit, LOGSTATEMENT_LATINIME_COMMITCURRENTAUTOCORRECTION,
                 scrubbedTypedWord, scrubbedAutoCorrection, separatorString);
-        researchLogger.commitCurrentLogUnitAsWord(scrubbedAutoCorrection, Long.MAX_VALUE);
     }
 
     private boolean isExpectingCommitText = false;
@@ -1340,13 +1484,13 @@
     // add invocations.
     private static final LogStatement LOGSTATEMENT_LATINIME_COMMIT_PARTIAL_TEXT =
             new LogStatement("LatinIMECommitPartialText", true, false, "newCursorPosition");
-    public static void latinIME_commitPartialText(final CharSequence committedWord,
-            final long lastTimestampOfWordData) {
+    public static void latinIME_commitPartialText(final String committedWord,
+            final long lastTimestampOfWordData, final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        final String scrubbedWord = scrubDigitsFromString(committedWord.toString());
+        final String scrubbedWord = scrubDigitsFromString(committedWord);
         researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_COMMIT_PARTIAL_TEXT);
-        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, lastTimestampOfWordData);
-        researchLogger.mStatistics.recordSplitWords();
+        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, lastTimestampOfWordData,
+                isBatchMode);
     }
 
     /**
@@ -1357,14 +1501,14 @@
      */
     private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTIONCOMMITTEXT =
             new LogStatement("RichInputConnectionCommitText", true, false, "newCursorPosition");
-    public static void richInputConnection_commitText(final CharSequence committedWord,
-            final int newCursorPosition) {
+    public static void richInputConnection_commitText(final String committedWord,
+            final int newCursorPosition, final boolean isBatchMode) {
         final ResearchLogger researchLogger = getInstance();
-        final String scrubbedWord = scrubDigitsFromString(committedWord.toString());
+        final String scrubbedWord = scrubDigitsFromString(committedWord);
         if (!researchLogger.isExpectingCommitText) {
             researchLogger.enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTIONCOMMITTEXT,
                     newCursorPosition);
-            researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE);
+            researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE, isBatchMode);
         }
         researchLogger.isExpectingCommitText = false;
     }
@@ -1373,9 +1517,9 @@
      * Shared event for logging committed text.
      */
     private static final LogStatement LOGSTATEMENT_COMMITTEXT =
-            new LogStatement("CommitText", true, false, "committedText");
-    private void enqueueCommitText(final CharSequence word) {
-        enqueueEvent(LOGSTATEMENT_COMMITTEXT, word);
+            new LogStatement("CommitText", true, false, "committedText", "isBatchMode");
+    private void enqueueCommitText(final String word, final boolean isBatchMode) {
+        enqueueEvent(LOGSTATEMENT_COMMITTEXT, word, isBatchMode);
     }
 
     /**
@@ -1515,20 +1659,62 @@
         final ResearchLogger researchLogger = getInstance();
         researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_ONENDBATCHINPUT, enteredText,
                 enteredWordPos);
-        researchLogger.mStatistics.recordGestureInput(enteredText.length());
+        researchLogger.mStatistics.recordGestureInput(enteredText.length(),
+                SystemClock.uptimeMillis());
     }
 
     /**
-     * Log a call to LatinIME.handleBackspace().
+     * Log a call to LatinIME.handleBackspace() that is not a batch delete.
+     *
+     * UserInput: The user is deleting one or more characters by hitting the backspace key once.
+     * The covers single character deletes as well as deleting selections.
+     */
+    private static final LogStatement LOGSTATEMENT_LATINIME_HANDLEBACKSPACE =
+            new LogStatement("LatinIMEHandleBackspace", true, false, "numCharacters");
+    public static void latinIME_handleBackspace(final int numCharacters) {
+        final ResearchLogger researchLogger = getInstance();
+        researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_HANDLEBACKSPACE, numCharacters);
+    }
+
+    /**
+     * Log a call to LatinIME.handleBackspace() that is a batch delete.
      *
      * UserInput: The user is deleting a gestured word by hitting the backspace key once.
      */
     private static final LogStatement LOGSTATEMENT_LATINIME_HANDLEBACKSPACE_BATCH =
-            new LogStatement("LatinIMEHandleBackspaceBatch", true, false, "deletedText");
-    public static void latinIME_handleBackspace_batch(final CharSequence deletedText) {
+            new LogStatement("LatinIMEHandleBackspaceBatch", true, false, "deletedText",
+                    "numCharacters");
+    public static void latinIME_handleBackspace_batch(final CharSequence deletedText,
+            final int numCharacters) {
         final ResearchLogger researchLogger = getInstance();
-        researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_HANDLEBACKSPACE_BATCH, deletedText);
-        researchLogger.mStatistics.recordGestureDelete();
+        researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_HANDLEBACKSPACE_BATCH, deletedText,
+                numCharacters);
+        researchLogger.mStatistics.recordGestureDelete(deletedText.length(),
+                SystemClock.uptimeMillis());
+    }
+
+    /**
+     * Log a long interval between user operation.
+     *
+     * UserInput: The user has not done anything for a while.
+     */
+    private static final LogStatement LOGSTATEMENT_ONUSERPAUSE = new LogStatement("OnUserPause",
+            false, false, "intervalInMs");
+    public static void onUserPause(final long interval) {
+        final ResearchLogger researchLogger = getInstance();
+        researchLogger.enqueueEvent(LOGSTATEMENT_ONUSERPAUSE, interval);
+    }
+
+    /**
+     * Record the current time in case the LogUnit is later split.
+     *
+     * If the current logUnitis split, then tapping, motion events, etc. before this time should
+     * be assigned to one LogUnit, and events after this time should go into the following LogUnit.
+     */
+    public static void recordTimeForLogUnitSplit() {
+        final ResearchLogger researchLogger = getInstance();
+        researchLogger.setSavedDownEventTime(SystemClock.uptimeMillis());
+        researchLogger.mSavedDownEventTime = Long.MAX_VALUE;
     }
 
     /**
diff --git a/java/src/com/android/inputmethod/research/Statistics.java b/java/src/com/android/inputmethod/research/Statistics.java
index e9c02c9..a920265 100644
--- a/java/src/com/android/inputmethod/research/Statistics.java
+++ b/java/src/com/android/inputmethod/research/Statistics.java
@@ -134,17 +134,9 @@
         if (DEBUG) {
             Log.d(TAG, "recordChar() called");
         }
-        final long delta = time - mLastTapTime;
         if (codePoint == Constants.CODE_DELETE) {
             mDeleteKeyCount++;
-            if (delta < MIN_DELETION_INTERMISSION) {
-                if (mIsLastKeyDeleteKey) {
-                    mDuringRepeatedDeleteKeysCounter.add(delta);
-                } else {
-                    mBeforeDeleteKeyCounter.add(delta);
-                }
-            }
-            mIsLastKeyDeleteKey = true;
+            recordUserAction(time, true /* isDeletion */);
         } else {
             mCharCount++;
             if (Character.isDigit(codePoint)) {
@@ -156,14 +148,8 @@
             if (Character.isSpaceChar(codePoint)) {
                 mSpaceCount++;
             }
-            if (mIsLastKeyDeleteKey && delta < MIN_DELETION_INTERMISSION) {
-                mAfterDeleteKeyCounter.add(delta);
-            } else if (!mIsLastKeyDeleteKey && delta < MIN_TYPING_INTERMISSION) {
-                mKeyCounter.add(delta);
-            }
-            mIsLastKeyDeleteKey = false;
+            recordUserAction(time, false /* isDeletion */);
         }
-        mLastTapTime = time;
     }
 
     public void recordWordEntered(final boolean isDictionaryWord) {
@@ -177,9 +163,10 @@
         mSplitWordsCount++;
     }
 
-    public void recordGestureInput(final int numCharsEntered) {
+    public void recordGestureInput(final int numCharsEntered, final long time) {
         mGesturesInputCount++;
         mGesturesCharsCount += numCharsEntered;
+        recordUserAction(time, false /* isDeletion */);
     }
 
     public void setIsEmptyUponStarting(final boolean isEmpty) {
@@ -187,14 +174,43 @@
         mIsEmptinessStateKnown = true;
     }
 
-    public void recordGestureDelete() {
+    public void recordGestureDelete(final int length, final long time) {
         mGesturesDeletedCount++;
-    }
-    public void recordManualSuggestion() {
-        mManualSuggestionsCount++;
+        recordUserAction(time, true /* isDeletion */);
     }
 
-    public void recordRevertCommit() {
+    public void recordManualSuggestion(final long time) {
+        mManualSuggestionsCount++;
+        recordUserAction(time, false /* isDeletion */);
+    }
+
+    public void recordRevertCommit(final long time) {
         mRevertCommitsCount++;
+        recordUserAction(time, true /* isDeletion */);
+    }
+
+    private void recordUserAction(final long time, final boolean isDeletion) {
+        final long delta = time - mLastTapTime;
+        if (isDeletion) {
+            if (delta < MIN_DELETION_INTERMISSION) {
+                if (mIsLastKeyDeleteKey) {
+                    mDuringRepeatedDeleteKeysCounter.add(delta);
+                } else {
+                    mBeforeDeleteKeyCounter.add(delta);
+                }
+            } else {
+                ResearchLogger.onUserPause(delta);
+            }
+        } else {
+            if (mIsLastKeyDeleteKey && delta < MIN_DELETION_INTERMISSION) {
+                mAfterDeleteKeyCounter.add(delta);
+            } else if (!mIsLastKeyDeleteKey && delta < MIN_TYPING_INTERMISSION) {
+                mKeyCounter.add(delta);
+            } else {
+                ResearchLogger.onUserPause(delta);
+            }
+        }
+        mIsLastKeyDeleteKey = isDeletion;
+        mLastTapTime = time;
     }
 }
diff --git a/native/jni/Android.mk b/native/jni/Android.mk
index 75f85b1..f2aebd5 100644
--- a/native/jni/Android.mk
+++ b/native/jni/Android.mk
@@ -66,11 +66,11 @@
 
 ifeq ($(FLAG_DO_PROFILE), true)
     $(warning Making profiling version of native library)
-    LOCAL_CFLAGS += -DFLAG_DO_PROFILE -funwind-tables
+    LOCAL_CFLAGS += -DFLAG_DO_PROFILE -funwind-tables -fno-inline
 else # FLAG_DO_PROFILE
 ifeq ($(FLAG_DBG), true)
     $(warning Making debug version of native library)
-    LOCAL_CFLAGS += -DFLAG_DBG -funwind-tables
+    LOCAL_CFLAGS += -DFLAG_DBG -funwind-tables -fno-inline
 ifeq ($(FLAG_FULL_DBG), true)
     $(warning Making full debug version of native library)
     LOCAL_CFLAGS += -DFLAG_FULL_DBG
diff --git a/native/jni/com_android_inputmethod_keyboard_ProximityInfo.cpp b/native/jni/com_android_inputmethod_keyboard_ProximityInfo.cpp
index 4c83c58..d718290 100644
--- a/native/jni/com_android_inputmethod_keyboard_ProximityInfo.cpp
+++ b/native/jni/com_android_inputmethod_keyboard_ProximityInfo.cpp
@@ -24,12 +24,12 @@
 
 namespace latinime {
 
-static jlong latinime_Keyboard_setProximityInfo(JNIEnv *env, jobject object,
-        jstring localeJStr, jint maxProximityCharsSize, jint displayWidth, jint displayHeight,
-        jint gridWidth, jint gridHeight, jint mostCommonkeyWidth, jintArray proximityChars,
-        jint keyCount, jintArray keyXCoordinates, jintArray keyYCoordinates,
-        jintArray keyWidths, jintArray keyHeights, jintArray keyCharCodes,
-        jfloatArray sweetSpotCenterXs, jfloatArray sweetSpotCenterYs, jfloatArray sweetSpotRadii) {
+static jlong latinime_Keyboard_setProximityInfo(JNIEnv *env, jclass clazz, jstring localeJStr,
+        jint maxProximityCharsSize, jint displayWidth, jint displayHeight, jint gridWidth,
+        jint gridHeight, jint mostCommonkeyWidth, jintArray proximityChars, jint keyCount,
+        jintArray keyXCoordinates, jintArray keyYCoordinates, jintArray keyWidths,
+        jintArray keyHeights, jintArray keyCharCodes, jfloatArray sweetSpotCenterXs,
+        jfloatArray sweetSpotCenterYs, jfloatArray sweetSpotRadii) {
     ProximityInfo *proximityInfo = new ProximityInfo(env, localeJStr, maxProximityCharsSize,
             displayWidth, displayHeight, gridWidth, gridHeight, mostCommonkeyWidth, proximityChars,
             keyCount, keyXCoordinates, keyYCoordinates, keyWidths, keyHeights, keyCharCodes,
@@ -37,7 +37,7 @@
     return reinterpret_cast<jlong>(proximityInfo);
 }
 
-static void latinime_Keyboard_release(JNIEnv *env, jobject object, jlong proximityInfo) {
+static void latinime_Keyboard_release(JNIEnv *env, jclass clazz, jlong proximityInfo) {
     ProximityInfo *pi = reinterpret_cast<ProximityInfo *>(proximityInfo);
     delete pi;
 }
diff --git a/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp b/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
index 4e34f98..5c8ef7e 100644
--- a/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
+++ b/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
@@ -42,8 +42,8 @@
 
 static void releaseDictBuf(const void *dictBuf, const size_t length, const int fd);
 
-static jlong latinime_BinaryDictionary_open(JNIEnv *env, jobject object, jstring sourceDir,
-        jlong dictOffset, jlong dictSize, jint maxWordLength, jint maxWords, jint maxPredictions) {
+static jlong latinime_BinaryDictionary_open(JNIEnv *env, jclass clazz, jstring sourceDir,
+        jlong dictOffset, jlong dictSize) {
     PROF_OPEN;
     PROF_START(66);
     const jsize sourceDirUtf8Length = env->GetStringUTFLength(sourceDir);
@@ -117,18 +117,17 @@
         releaseDictBuf(dictBuf, 0, 0);
 #endif // USE_MMAP_FOR_DICTIONARY
     } else {
-        dictionary = new Dictionary(dictBuf, static_cast<int>(dictSize), fd, adjust, maxWordLength,
-                maxWords, maxPredictions);
+        dictionary = new Dictionary(dictBuf, static_cast<int>(dictSize), fd, adjust);
     }
     PROF_END(66);
     PROF_CLOSE;
     return (jlong)dictionary;
 }
 
-static int latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jobject object, jlong dict,
+static int latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jclass clazz, jlong dict,
         jlong proximityInfo, jlong dicTraverseSession, jintArray xCoordinatesArray,
         jintArray yCoordinatesArray, jintArray timesArray, jintArray pointerIdsArray,
-        jintArray inputCodePointsArray, jint arraySize, jint commitPoint, jboolean isGesture,
+        jintArray inputCodePointsArray, jint inputSize, jint commitPoint, jboolean isGesture,
         jintArray prevWordCodePointsForBigrams, jboolean useFullEditDistance,
         jintArray outputCodePointsArray, jintArray scoresArray, jintArray spaceIndicesArray,
         jintArray outputTypesArray) {
@@ -138,20 +137,20 @@
     void *traverseSession = reinterpret_cast<void *>(dicTraverseSession);
 
     // Input values
-    int xCoordinates[arraySize];
-    int yCoordinates[arraySize];
-    int times[arraySize];
-    int pointerIds[arraySize];
+    int xCoordinates[inputSize];
+    int yCoordinates[inputSize];
+    int times[inputSize];
+    int pointerIds[inputSize];
     const jsize inputCodePointsLength = env->GetArrayLength(inputCodePointsArray);
     int inputCodePoints[inputCodePointsLength];
     const jsize prevWordCodePointsLength =
             prevWordCodePointsForBigrams ? env->GetArrayLength(prevWordCodePointsForBigrams) : 0;
     int prevWordCodePointsInternal[prevWordCodePointsLength];
     int *prevWordCodePoints = 0;
-    env->GetIntArrayRegion(xCoordinatesArray, 0, arraySize, xCoordinates);
-    env->GetIntArrayRegion(yCoordinatesArray, 0, arraySize, yCoordinates);
-    env->GetIntArrayRegion(timesArray, 0, arraySize, times);
-    env->GetIntArrayRegion(pointerIdsArray, 0, arraySize, pointerIds);
+    env->GetIntArrayRegion(xCoordinatesArray, 0, inputSize, xCoordinates);
+    env->GetIntArrayRegion(yCoordinatesArray, 0, inputSize, yCoordinates);
+    env->GetIntArrayRegion(timesArray, 0, inputSize, times);
+    env->GetIntArrayRegion(pointerIdsArray, 0, inputSize, pointerIds);
     env->GetIntArrayRegion(inputCodePointsArray, 0, inputCodePointsLength, inputCodePoints);
     if (prevWordCodePointsForBigrams) {
         env->GetIntArrayRegion(prevWordCodePointsForBigrams, 0, prevWordCodePointsLength,
@@ -160,9 +159,20 @@
     }
 
     // Output values
+    /* By the way, let's check the output array length here to make sure */
     const jsize outputCodePointsLength = env->GetArrayLength(outputCodePointsArray);
-    int outputCodePoints[outputCodePointsLength];
+    if (outputCodePointsLength != (MAX_WORD_LENGTH * MAX_RESULTS)) {
+        AKLOGE("Invalid outputCodePointsLength: %d", outputCodePointsLength);
+        ASSERT(false);
+        return 0;
+    }
     const jsize scoresLength = env->GetArrayLength(scoresArray);
+    if (scoresLength != MAX_RESULTS) {
+        AKLOGE("Invalid scoresLength: %d", scoresLength);
+        ASSERT(false);
+        return 0;
+    }
+    int outputCodePoints[outputCodePointsLength];
     int scores[scoresLength];
     const jsize spaceIndicesLength = env->GetArrayLength(spaceIndicesArray);
     int spaceIndices[spaceIndicesLength];
@@ -174,14 +184,14 @@
     memset(outputTypes, 0, sizeof(outputTypes));
 
     int count;
-    if (isGesture || arraySize > 0) {
+    if (isGesture || inputSize > 0) {
         count = dictionary->getSuggestions(pInfo, traverseSession, xCoordinates, yCoordinates,
-                times, pointerIds, inputCodePoints, arraySize, prevWordCodePoints,
+                times, pointerIds, inputCodePoints, inputSize, prevWordCodePoints,
                 prevWordCodePointsLength, commitPoint, isGesture, useFullEditDistance,
                 outputCodePoints, scores, spaceIndices, outputTypes);
     } else {
         count = dictionary->getBigrams(prevWordCodePoints, prevWordCodePointsLength,
-                inputCodePoints, arraySize, outputCodePoints, scores, outputTypes);
+                inputCodePoints, inputSize, outputCodePoints, scores, outputTypes);
     }
 
     // Copy back the output values
@@ -193,7 +203,7 @@
     return count;
 }
 
-static jint latinime_BinaryDictionary_getFrequency(JNIEnv *env, jobject object, jlong dict,
+static jint latinime_BinaryDictionary_getFrequency(JNIEnv *env, jclass clazz, jlong dict,
         jintArray wordArray) {
     Dictionary *dictionary = reinterpret_cast<Dictionary *>(dict);
     if (!dictionary) return 0;
@@ -203,7 +213,7 @@
     return dictionary->getFrequency(codePoints, codePointLength);
 }
 
-static jboolean latinime_BinaryDictionary_isValidBigram(JNIEnv *env, jobject object, jlong dict,
+static jboolean latinime_BinaryDictionary_isValidBigram(JNIEnv *env, jclass clazz, jlong dict,
         jintArray wordArray1, jintArray wordArray2) {
     Dictionary *dictionary = reinterpret_cast<Dictionary *>(dict);
     if (!dictionary) return (jboolean) false;
@@ -216,7 +226,7 @@
     return dictionary->isValidBigram(codePoints1, codePointLength1, codePoints2, codePointLength2);
 }
 
-static jfloat latinime_BinaryDictionary_calcNormalizedScore(JNIEnv *env, jobject object,
+static jfloat latinime_BinaryDictionary_calcNormalizedScore(JNIEnv *env, jclass clazz,
         jintArray before, jintArray after, jint score) {
     jsize beforeLength = env->GetArrayLength(before);
     jsize afterLength = env->GetArrayLength(after);
@@ -228,7 +238,7 @@
             afterCodePoints, afterLength, score);
 }
 
-static jint latinime_BinaryDictionary_editDistance(JNIEnv *env, jobject object, jintArray before,
+static jint latinime_BinaryDictionary_editDistance(JNIEnv *env, jclass clazz, jintArray before,
         jintArray after) {
     jsize beforeLength = env->GetArrayLength(before);
     jsize afterLength = env->GetArrayLength(after);
@@ -240,7 +250,7 @@
             afterCodePoints, afterLength);
 }
 
-static void latinime_BinaryDictionary_close(JNIEnv *env, jobject object, jlong dict) {
+static void latinime_BinaryDictionary_close(JNIEnv *env, jclass clazz, jlong dict) {
     Dictionary *dictionary = reinterpret_cast<Dictionary *>(dict);
     if (!dictionary) return;
     const void *dictBuf = dictionary->getDict();
@@ -270,7 +280,7 @@
 }
 
 static JNINativeMethod sMethods[] = {
-    {"openNative", "(Ljava/lang/String;JJIII)J",
+    {"openNative", "(Ljava/lang/String;JJ)J",
             reinterpret_cast<void *>(latinime_BinaryDictionary_open)},
     {"closeNative", "(J)V", reinterpret_cast<void *>(latinime_BinaryDictionary_close)},
     {"getSuggestionsNative", "(JJJ[I[I[I[I[IIIZ[IZ[I[I[I[I)I",
diff --git a/native/jni/com_android_inputmethod_latin_DicTraverseSession.cpp b/native/jni/com_android_inputmethod_latin_DicTraverseSession.cpp
index 73ac84c..9b39245 100644
--- a/native/jni/com_android_inputmethod_latin_DicTraverseSession.cpp
+++ b/native/jni/com_android_inputmethod_latin_DicTraverseSession.cpp
@@ -24,12 +24,12 @@
 
 namespace latinime {
 class Dictionary;
-static jlong latinime_setDicTraverseSession(JNIEnv *env, jobject object, jstring localeJStr) {
+static jlong latinime_setDicTraverseSession(JNIEnv *env, jclass clazz, jstring localeJStr) {
     void *traverseSession = DicTraverseWrapper::getDicTraverseSession(env, localeJStr);
     return reinterpret_cast<jlong>(traverseSession);
 }
 
-static void latinime_initDicTraverseSession(JNIEnv *env, jobject object, jlong traverseSession,
+static void latinime_initDicTraverseSession(JNIEnv *env, jclass clazz, jlong traverseSession,
         jlong dictionary, jintArray previousWord, jint previousWordLength) {
     void *ts = reinterpret_cast<void *>(traverseSession);
     Dictionary *dict = reinterpret_cast<Dictionary *>(dictionary);
@@ -42,7 +42,7 @@
     DicTraverseWrapper::initDicTraverseSession(ts, dict, prevWord, previousWordLength);
 }
 
-static void latinime_releaseDicTraverseSession(JNIEnv *env, jobject object, jlong traverseSession) {
+static void latinime_releaseDicTraverseSession(JNIEnv *env, jclass clazz, jlong traverseSession) {
     void *ts = reinterpret_cast<void *>(traverseSession);
     DicTraverseWrapper::releaseDicTraverseSession(ts);
 }
diff --git a/native/jni/src/bigram_dictionary.cpp b/native/jni/src/bigram_dictionary.cpp
index e62ae6f..44dc75e 100644
--- a/native/jni/src/bigram_dictionary.cpp
+++ b/native/jni/src/bigram_dictionary.cpp
@@ -26,8 +26,7 @@
 
 namespace latinime {
 
-BigramDictionary::BigramDictionary(const unsigned char *dict, int maxWordLength, int maxPredictions)
-        : DICT(dict), MAX_WORD_LENGTH(maxWordLength), MAX_PREDICTIONS(maxPredictions) {
+BigramDictionary::BigramDictionary(const uint8_t *const streamStart) : DICT_ROOT(streamStart) {
     if (DEBUG_DICT) {
         AKLOGI("BigramDictionary - constructor");
     }
@@ -36,7 +35,7 @@
 BigramDictionary::~BigramDictionary() {
 }
 
-bool BigramDictionary::addWordBigram(int *word, int length, int frequency, int *bigramFreq,
+void BigramDictionary::addWordBigram(int *word, int length, int frequency, int *bigramFreq,
         int *bigramCodePoints, int *outputTypes) const {
     word[length] = 0;
     if (DEBUG_DICT) {
@@ -49,7 +48,7 @@
 
     // Find the right insertion point
     int insertAt = 0;
-    while (insertAt < MAX_PREDICTIONS) {
+    while (insertAt < MAX_RESULTS) {
         if (frequency > bigramFreq[insertAt] || (bigramFreq[insertAt] == frequency
                 && length < Dictionary::wideStrLen(
                         bigramCodePoints + insertAt * MAX_WORD_LENGTH))) {
@@ -58,35 +57,34 @@
         insertAt++;
     }
     if (DEBUG_DICT) {
-        AKLOGI("Bigram: InsertAt -> %d MAX_PREDICTIONS: %d", insertAt, MAX_PREDICTIONS);
+        AKLOGI("Bigram: InsertAt -> %d MAX_RESULTS: %d", insertAt, MAX_RESULTS);
     }
-    if (insertAt < MAX_PREDICTIONS) {
-        memmove(bigramFreq + (insertAt + 1),
-                bigramFreq + insertAt,
-                (MAX_PREDICTIONS - insertAt - 1) * sizeof(bigramFreq[0]));
-        bigramFreq[insertAt] = frequency;
-        outputTypes[insertAt] = Dictionary::KIND_PREDICTION;
-        memmove(bigramCodePoints + (insertAt + 1) * MAX_WORD_LENGTH,
-                bigramCodePoints + insertAt * MAX_WORD_LENGTH,
-                (MAX_PREDICTIONS - insertAt - 1) * sizeof(bigramCodePoints[0]) * MAX_WORD_LENGTH);
-        int *dest = bigramCodePoints + insertAt * MAX_WORD_LENGTH;
-        while (length--) {
-            *dest++ = *word++;
-        }
-        *dest = 0; // NULL terminate
-        if (DEBUG_DICT) {
-            AKLOGI("Bigram: Added word at %d", insertAt);
-        }
-        return true;
+    if (insertAt >= MAX_RESULTS) {
+        return;
     }
-    return false;
+    memmove(bigramFreq + (insertAt + 1),
+            bigramFreq + insertAt,
+            (MAX_RESULTS - insertAt - 1) * sizeof(bigramFreq[0]));
+    bigramFreq[insertAt] = frequency;
+    outputTypes[insertAt] = Dictionary::KIND_PREDICTION;
+    memmove(bigramCodePoints + (insertAt + 1) * MAX_WORD_LENGTH,
+            bigramCodePoints + insertAt * MAX_WORD_LENGTH,
+            (MAX_RESULTS - insertAt - 1) * sizeof(bigramCodePoints[0]) * MAX_WORD_LENGTH);
+    int *dest = bigramCodePoints + insertAt * MAX_WORD_LENGTH;
+    while (length--) {
+        *dest++ = *word++;
+    }
+    *dest = 0; // NULL terminate
+    if (DEBUG_DICT) {
+        AKLOGI("Bigram: Added word at %d", insertAt);
+    }
 }
 
 /* Parameters :
  * prevWord: the word before, the one for which we need to look up bigrams.
  * prevWordLength: its length.
- * inputCodes: what user typed, in the same format as for UnigramDictionary::getSuggestions.
- * codesSize: the size of the codes array.
+ * inputCodePoints: what user typed, in the same format as for UnigramDictionary::getSuggestions.
+ * inputSize: the size of the codes array.
  * bigramCodePoints: an array for output, at the same format as outwords for getSuggestions.
  * bigramFreq: an array to output frequencies.
  * outputTypes: an array to output types.
@@ -98,12 +96,12 @@
  * and the bigrams are used to boost unigram result scores, it makes little sense to
  * reduce their scope to the ones that match the first letter.
  */
-int BigramDictionary::getBigrams(const int *prevWord, int prevWordLength, int *inputCodes,
-        int codesSize, int *bigramCodePoints, int *bigramFreq, int *outputTypes) const {
+int BigramDictionary::getBigrams(const int *prevWord, int prevWordLength, int *inputCodePoints,
+        int inputSize, int *bigramCodePoints, int *bigramFreq, int *outputTypes) const {
     // TODO: remove unused arguments, and refrain from storing stuff in members of this class
     // TODO: have "in" arguments before "out" ones, and make out args explicit in the name
 
-    const uint8_t *const root = DICT;
+    const uint8_t *const root = DICT_ROOT;
     int pos = getBigramListPositionForWord(prevWord, prevWordLength,
             false /* forceLowerCaseSearch */);
     // getBigramListPositionForWord returns 0 if this word isn't in the dictionary or has no bigrams
@@ -125,8 +123,8 @@
         const int length = BinaryFormat::getWordAtAddress(root, bigramPos, MAX_WORD_LENGTH,
                 bigramBuffer, &unigramFreq);
 
-        // codesSize == 0 means we are trying to find bigram predictions.
-        if (codesSize < 1 || checkFirstCharacter(bigramBuffer, inputCodes)) {
+        // inputSize == 0 means we are trying to find bigram predictions.
+        if (inputSize < 1 || checkFirstCharacter(bigramBuffer, inputCodePoints)) {
             const int bigramFreqTemp = BinaryFormat::MASK_ATTRIBUTE_FREQUENCY & bigramFlags;
             // Due to space constraints, the frequency for bigrams is approximate - the lower the
             // unigram frequency, the worse the precision. The theoritical maximum error in
@@ -135,13 +133,12 @@
             // here, but it can't get too bad.
             const int frequency =
                     BinaryFormat::computeFrequencyForBigram(unigramFreq, bigramFreqTemp);
-            if (addWordBigram(bigramBuffer, length, frequency, bigramFreq, bigramCodePoints,
-                    outputTypes)) {
-                ++bigramCount;
-            }
+            addWordBigram(bigramBuffer, length, frequency, bigramFreq, bigramCodePoints,
+                    outputTypes);
+            ++bigramCount;
         }
     } while (BinaryFormat::FLAG_ATTRIBUTE_HAS_NEXT & bigramFlags);
-    return bigramCount;
+    return min(bigramCount, MAX_RESULTS);
 }
 
 // Returns a pointer to the start of the bigram list.
@@ -149,7 +146,7 @@
 int BigramDictionary::getBigramListPositionForWord(const int *prevWord, const int prevWordLength,
         const bool forceLowerCaseSearch) const {
     if (0 >= prevWordLength) return 0;
-    const uint8_t *const root = DICT;
+    const uint8_t *const root = DICT_ROOT;
     int pos = BinaryFormat::getTerminalPosition(root, prevWord, prevWordLength,
             forceLowerCaseSearch);
 
@@ -170,7 +167,7 @@
 void BigramDictionary::fillBigramAddressToFrequencyMapAndFilter(const int *prevWord,
         const int prevWordLength, std::map<int, int> *map, uint8_t *filter) const {
     memset(filter, 0, BIGRAM_FILTER_BYTE_SIZE);
-    const uint8_t *const root = DICT;
+    const uint8_t *const root = DICT_ROOT;
     int pos = getBigramListPositionForWord(prevWord, prevWordLength,
             false /* forceLowerCaseSearch */);
     if (0 == pos) {
@@ -191,17 +188,17 @@
     } while (0 != (BinaryFormat::FLAG_ATTRIBUTE_HAS_NEXT & bigramFlags));
 }
 
-bool BigramDictionary::checkFirstCharacter(int *word, int *inputCodes) const {
+bool BigramDictionary::checkFirstCharacter(int *word, int *inputCodePoints) const {
     // Checks whether this word starts with same character or neighboring characters of
     // what user typed.
 
     int maxAlt = MAX_ALTERNATIVES;
-    const int firstBaseChar = toBaseLowerCase(*word);
+    const int firstBaseLowerCodePoint = toBaseLowerCase(*word);
     while (maxAlt > 0) {
-        if (toBaseLowerCase(*inputCodes) == firstBaseChar) {
+        if (toBaseLowerCase(*inputCodePoints) == firstBaseLowerCodePoint) {
             return true;
         }
-        inputCodes++;
+        inputCodePoints++;
         maxAlt--;
     }
     return false;
@@ -209,7 +206,7 @@
 
 bool BigramDictionary::isValidBigram(const int *word1, int length1, const int *word2,
         int length2) const {
-    const uint8_t *const root = DICT;
+    const uint8_t *const root = DICT_ROOT;
     int pos = getBigramListPositionForWord(word1, length1, false /* forceLowerCaseSearch */);
     // getBigramListPositionForWord returns 0 if this word isn't in the dictionary or has no bigrams
     if (0 == pos) return false;
diff --git a/native/jni/src/bigram_dictionary.h b/native/jni/src/bigram_dictionary.h
index 150192d..2ce6c1d 100644
--- a/native/jni/src/bigram_dictionary.h
+++ b/native/jni/src/bigram_dictionary.h
@@ -26,8 +26,8 @@
 
 class BigramDictionary {
  public:
-    BigramDictionary(const unsigned char *dict, int maxWordLength, int maxPredictions);
-    int getBigrams(const int *word, int length, int *inputCodes, int codesSize, int *outWords,
+    BigramDictionary(const uint8_t *const streamStart);
+    int getBigrams(const int *word, int length, int *inputCodePoints, int inputSize, int *outWords,
             int *frequencies, int *outputTypes) const;
     void fillBigramAddressToFrequencyMapAndFilter(const int *prevWord, const int prevWordLength,
             std::map<int, int> *map, uint8_t *filter) const;
@@ -35,20 +35,13 @@
     ~BigramDictionary();
  private:
     DISALLOW_IMPLICIT_CONSTRUCTORS(BigramDictionary);
-    bool addWordBigram(int *word, int length, int frequency, int *bigramFreq, int *bigramCodePoints,
+    void addWordBigram(int *word, int length, int frequency, int *bigramFreq, int *bigramCodePoints,
             int *outputTypes) const;
-    int getBigramAddress(int *pos, bool advance);
-    int getBigramFreq(int *pos);
-    void searchForTerminalNode(int addressLookingFor, int frequency);
-    bool getFirstBitOfByte(int *pos) { return (DICT[*pos] & 0x80) > 0; }
-    bool getSecondBitOfByte(int *pos) { return (DICT[*pos] & 0x40) > 0; }
-    bool checkFirstCharacter(int *word, int *inputCodes) const;
+    bool checkFirstCharacter(int *word, int *inputCodePoints) const;
     int getBigramListPositionForWord(const int *prevWord, const int prevWordLength,
             const bool forceLowerCaseSearch) const;
 
-    const unsigned char *DICT;
-    const int MAX_WORD_LENGTH;
-    const int MAX_PREDICTIONS;
+    const uint8_t *const DICT_ROOT;
     // TODO: Re-implement proximity correction for bigram correction
     static const int MAX_ALTERNATIVES = 1;
 };
diff --git a/native/jni/src/correction.cpp b/native/jni/src/correction.cpp
index a0256ee..e892c85 100644
--- a/native/jni/src/correction.cpp
+++ b/native/jni/src/correction.cpp
@@ -16,10 +16,13 @@
 
 #define LOG_TAG "LatinIME: correction.cpp"
 
+#include <cmath>
+
 #include "char_utils.h"
 #include "correction.h"
 #include "defines.h"
 #include "proximity_info_state.h"
+#include "suggest_utils.h"
 
 namespace latinime {
 
@@ -30,7 +33,7 @@
 /////////////////////////////
 
 inline static void initEditDistance(int *editDistanceTable) {
-    for (int i = 0; i <= MAX_WORD_LENGTH_INTERNAL; ++i) {
+    for (int i = 0; i <= MAX_WORD_LENGTH; ++i) {
         editDistanceTable[i] = i;
     }
 }
@@ -77,7 +80,7 @@
     mMaxDepth = maxDepth;
     mMaxEditDistance = mInputSize < 5 ? 2 : mInputSize / 2;
     // TODO: This is not supposed to be required.  Check what's going wrong with
-    // editDistance[0 ~ MAX_WORD_LENGTH_INTERNAL]
+    // editDistance[0 ~ MAX_WORD_LENGTH]
     initEditDistance(mEditDistanceTable);
 }
 
@@ -671,27 +674,9 @@
             if (i < adjustedProximityMatchedCount) {
                 multiplyIntCapped(typedLetterMultiplier, &finalFreq);
             }
-            if (squaredDistance >= 0) {
-                // Promote or demote the score according to the distance from the sweet spot
-                static const float A = ZERO_DISTANCE_PROMOTION_RATE / 100.0f;
-                static const float B = 1.0f;
-                static const float C = 0.5f;
-                static const float MIN = 0.3f;
-                static const float R1 = NEUTRAL_SCORE_SQUARED_RADIUS;
-                static const float R2 = HALF_SCORE_SQUARED_RADIUS;
-                const float x = static_cast<float>(squaredDistance)
-                        / ProximityInfoState::NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR;
-                const float factor = max((x < R1)
-                        ? (A * (R1 - x) + B * x) / R1
-                        : (B * (R2 - x) + C * (x - R1)) / (R2 - R1), MIN);
-                // factor is a piecewise linear function like:
-                // A -_                  .
-                //     ^-_               .
-                // B      \              .
-                //         \_            .
-                // C         ------------.
-                //                       .
-                // 0   R1 R2             .
+            const float factor =
+                    SuggestUtils::getDistanceScalingFactor(static_cast<float>(squaredDistance));
+            if (factor > 0.0f) {
                 multiplyRate((int)(factor * 100.0f), &finalFreq);
             } else if (squaredDistance == PROXIMITY_CHAR_WITHOUT_DISTANCE_INFO) {
                 multiplyRate(WORDS_WITH_PROXIMITY_CHARACTER_DEMOTION_RATE, &finalFreq);
diff --git a/native/jni/src/correction.h b/native/jni/src/correction.h
index 8c47771..89e300d 100644
--- a/native/jni/src/correction.h
+++ b/native/jni/src/correction.h
@@ -57,7 +57,7 @@
     // Non virtual inline destructor -- never inherit this class
     ~Correction() {}
     void resetCorrection();
-    void initCorrection(const ProximityInfo *pi, const int inputSize, const int maxWordLength);
+    void initCorrection(const ProximityInfo *pi, const int inputSize, const int maxDepth);
     void initCorrectionState(const int rootPos, const int childCount, const bool traverseAll);
 
     // TODO: remove
@@ -237,14 +237,14 @@
     int mTotalTraverseCount;
 
     // The following arrays are state buffer.
-    int mWord[MAX_WORD_LENGTH_INTERNAL];
-    int mDistances[MAX_WORD_LENGTH_INTERNAL];
+    int mWord[MAX_WORD_LENGTH];
+    int mDistances[MAX_WORD_LENGTH];
 
     // Edit distance calculation requires a buffer with (N+1)^2 length for the input length N.
     // Caveat: Do not create multiple tables per thread as this table eats up RAM a lot.
-    int mEditDistanceTable[(MAX_WORD_LENGTH_INTERNAL + 1) * (MAX_WORD_LENGTH_INTERNAL + 1)];
+    int mEditDistanceTable[(MAX_WORD_LENGTH + 1) * (MAX_WORD_LENGTH + 1)];
 
-    CorrectionState mCorrectionStates[MAX_WORD_LENGTH_INTERNAL];
+    CorrectionState mCorrectionStates[MAX_WORD_LENGTH];
 
     // The following member variables are being used as cache values of the correction state.
     bool mNeedsToTraverseAllNodes;
@@ -336,7 +336,7 @@
 
 AK_FORCE_INLINE static void calcEditDistanceOneStep(int *editDistanceTable, const int *input,
         const int inputSize, const int *output, const int outputLength) {
-    // TODO: Make sure that editDistance[0 ~ MAX_WORD_LENGTH_INTERNAL] is not touched.
+    // TODO: Make sure that editDistance[0 ~ MAX_WORD_LENGTH] is not touched.
     // Let dp[i][j] be editDistanceTable[i * (inputSize + 1) + j].
     // Assuming that dp[0][0] ... dp[outputLength - 1][inputSize] are already calculated,
     // and calculate dp[ouputLength][0] ... dp[outputLength][inputSize].
diff --git a/native/jni/src/defines.h b/native/jni/src/defines.h
index 96abfe8..4d5a2b2 100644
--- a/native/jni/src/defines.h
+++ b/native/jni/src/defines.h
@@ -23,19 +23,25 @@
 #define AK_FORCE_INLINE inline
 #endif // __GNUC__
 
-// This must be greater than or equal to MAX_WORD_LENGTH defined in BinaryDictionary.java
-#define MAX_WORD_LENGTH_INTERNAL 48
+#if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
+#undef AK_FORCE_INLINE
+#define AK_FORCE_INLINE inline
+#endif // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
+
+// Must be identical to Constants.Dictionary.MAX_WORD_LENGTH in Java
+#define MAX_WORD_LENGTH 48
+// Must be identical to BinaryDictionary.MAX_RESULTS in Java
+#define MAX_RESULTS 18
 
 #if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
 #include <android/log.h>
 #ifndef LOG_TAG
 #define LOG_TAG "LatinIME: "
-#endif
+#endif // LOG_TAG
 #define AKLOGE(fmt, ...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, fmt, ##__VA_ARGS__)
 #define AKLOGI(fmt, ...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##__VA_ARGS__)
 
-#define DUMP_RESULT(words, frequencies, maxWordCount, maxWordLength) do { \
-        dumpResult(words, frequencies, maxWordCount, maxWordLength); } while (0)
+#define DUMP_RESULT(words, frequencies) do { dumpResult(words, frequencies); } while (0)
 #define DUMP_WORD(word, length) do { dumpWord(word, length); } while (0)
 #define INTS_TO_CHARS(input, length, output) do { \
         intArrayToCharArray(input, length, output); } while (0)
@@ -45,7 +51,7 @@
         char *dest) {
     int si = 0;
     int di = 0;
-    while (si < sourceSize && di < MAX_WORD_LENGTH_INTERNAL - 1 && 0 != source[si]) {
+    while (si < sourceSize && di < MAX_WORD_LENGTH - 1 && 0 != source[si]) {
         const int codePoint = source[si++];
         if (codePoint < 0x7F) {
             dest[di++] = codePoint;
@@ -71,11 +77,10 @@
     }
 }
 
-static inline void dumpResult(const int *outWords, const int *frequencies, const int maxWordCounts,
-        const int maxWordLength) {
+static inline void dumpResult(const int *outWords, const int *frequencies) {
     AKLOGI("--- DUMP RESULT ---------");
-    for (int i = 0; i < maxWordCounts; ++i) {
-        dumpWordInfo(&outWords[i * maxWordLength], maxWordLength, i, frequencies[i]);
+    for (int i = 0; i < MAX_RESULTS; ++i) {
+        dumpWordInfo(&outWords[i * MAX_WORD_LENGTH], MAX_WORD_LENGTH, i, frequencies[i]);
     }
     AKLOGI("-------------------------");
 }
@@ -110,23 +115,23 @@
     }
     free(strs);
 }
-#else
+#else // __ANDROID__
 #include <cassert>
 #define DO_ASSERT_TEST
 #define ASSERT(success) assert(success)
 #define SHOW_STACK_TRACE
-#endif
+#endif // __ANDROID__
 
-#else
+#else // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
 #define AKLOGE(fmt, ...)
 #define AKLOGI(fmt, ...)
-#define DUMP_RESULT(words, frequencies, maxWordCount, maxWordLength)
+#define DUMP_RESULT(words, frequencies)
 #define DUMP_WORD(word, length)
 #undef DO_ASSERT_TEST
 #define ASSERT(success)
 #define SHOW_STACK_TRACE
 #define INTS_TO_CHARS(input, length, output)
-#endif
+#endif // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
 
 #ifdef FLAG_DO_PROFILE
 // Profiler
@@ -311,7 +316,7 @@
 #define TWO_WORDS_CAPITALIZED_DEMOTION_RATE 50
 #define TWO_WORDS_CORRECTION_DEMOTION_BASE 80
 #define TWO_WORDS_PLUS_OTHER_ERROR_CORRECTION_DEMOTION_DIVIDER 1
-#define ZERO_DISTANCE_PROMOTION_RATE 110
+#define ZERO_DISTANCE_PROMOTION_RATE 110.0f
 #define NEUTRAL_SCORE_SQUARED_RADIUS 8.0f
 #define HALF_SCORE_SQUARED_RADIUS 32.0f
 #define MAX_FREQ 255
@@ -347,14 +352,8 @@
 #define SUPPRESS_SHORT_MULTIPLE_WORDS_THRESHOLD_FREQ (MAX_FREQ * 58 / 100)
 
 #define MAX_DEPTH_MULTIPLIER 3
-
 #define FIRST_WORD_INDEX 0
 
-#define MAX_SPACES_INTERNAL 16
-
-// TODO: Change this to MAX_WORDS, remove MAX_WORDS in Java, and stop getting it from Java
-#define MAX_WORDS_INTERNAL 18
-
 // Max Distance between point to key
 #define MAX_POINT_TO_KEY_LENGTH 10000000
 
diff --git a/native/jni/src/dictionary.cpp b/native/jni/src/dictionary.cpp
index 167b36f..2be1f4f 100644
--- a/native/jni/src/dictionary.cpp
+++ b/native/jni/src/dictionary.cpp
@@ -28,22 +28,13 @@
 
 namespace latinime {
 
-Dictionary::Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust, int maxWordLength,
-        int maxWords, int maxPredictions)
+Dictionary::Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust)
         : mDict(static_cast<unsigned char *>(dict)),
           mOffsetDict((static_cast<unsigned char *>(dict)) + BinaryFormat::getHeaderSize(mDict)),
           mDictSize(dictSize), mMmapFd(mmapFd), mDictBufAdjust(dictBufAdjust),
-          mUnigramDictionary(new UnigramDictionary(mOffsetDict, maxWordLength, maxWords,
-                  BinaryFormat::getFlags(mDict))),
-          mBigramDictionary(new BigramDictionary(mOffsetDict, maxWordLength, maxPredictions)),
-          mGestureSuggest(new GestureSuggest(maxWordLength, maxWords)) {
-    if (DEBUG_DICT) {
-        if (MAX_WORD_LENGTH_INTERNAL < maxWordLength) {
-            AKLOGI("Max word length (%d) is greater than %d",
-                    maxWordLength, MAX_WORD_LENGTH_INTERNAL);
-            AKLOGI("IN NATIVE SUGGEST Version: %d", (mDict[0] & 0xFF));
-        }
-    }
+          mUnigramDictionary(new UnigramDictionary(mOffsetDict, BinaryFormat::getFlags(mDict))),
+          mBigramDictionary(new BigramDictionary(mOffsetDict)),
+          mGestureSuggest(new GestureSuggest()) {
 }
 
 Dictionary::~Dictionary() {
@@ -53,38 +44,38 @@
 }
 
 int Dictionary::getSuggestions(ProximityInfo *proximityInfo, void *traverseSession,
-        int *xcoordinates, int *ycoordinates, int *times, int *pointerIds, int *codes,
-        int codesSize, int *prevWordChars, int prevWordLength, int commitPoint, bool isGesture,
+        int *xcoordinates, int *ycoordinates, int *times, int *pointerIds, int *inputCodePoints,
+        int inputSize, int *prevWordCodePoints, int prevWordLength, int commitPoint, bool isGesture,
         bool useFullEditDistance, int *outWords, int *frequencies, int *spaceIndices,
         int *outputTypes) const {
     int result = 0;
     if (isGesture) {
         DicTraverseWrapper::initDicTraverseSession(
-                traverseSession, this, prevWordChars, prevWordLength);
-        result = mGestureSuggest->getSuggestions(proximityInfo, traverseSession,
-                xcoordinates, ycoordinates, times, pointerIds, codes, codesSize, commitPoint,
-                outWords, frequencies, spaceIndices, outputTypes);
+                traverseSession, this, prevWordCodePoints, prevWordLength);
+        result = mGestureSuggest->getSuggestions(proximityInfo, traverseSession, xcoordinates,
+                ycoordinates, times, pointerIds, inputCodePoints, inputSize, commitPoint, outWords,
+                frequencies, spaceIndices, outputTypes);
         if (DEBUG_DICT) {
-            DUMP_RESULT(outWords, frequencies, 18 /* MAX_WORDS */, MAX_WORD_LENGTH_INTERNAL);
+            DUMP_RESULT(outWords, frequencies);
         }
         return result;
     } else {
         std::map<int, int> bigramMap;
         uint8_t bigramFilter[BIGRAM_FILTER_BYTE_SIZE];
-        mBigramDictionary->fillBigramAddressToFrequencyMapAndFilter(prevWordChars,
+        mBigramDictionary->fillBigramAddressToFrequencyMapAndFilter(prevWordCodePoints,
                 prevWordLength, &bigramMap, bigramFilter);
-        result = mUnigramDictionary->getSuggestions(proximityInfo, xcoordinates,
-                ycoordinates, codes, codesSize, &bigramMap, bigramFilter,
-                useFullEditDistance, outWords, frequencies, outputTypes);
+        result = mUnigramDictionary->getSuggestions(proximityInfo, xcoordinates, ycoordinates,
+                inputCodePoints, inputSize, &bigramMap, bigramFilter, useFullEditDistance, outWords,
+                frequencies, outputTypes);
         return result;
     }
 }
 
-int Dictionary::getBigrams(const int *word, int length, int *codes, int codesSize,
+int Dictionary::getBigrams(const int *word, int length, int *inputCodePoints, int inputSize,
         int *outWords, int *frequencies, int *outputTypes) const {
     if (length <= 0) return 0;
-    return mBigramDictionary->getBigrams(word, length, codes, codesSize, outWords, frequencies,
-            outputTypes);
+    return mBigramDictionary->getBigrams(word, length, inputCodePoints, inputSize, outWords,
+            frequencies, outputTypes);
 }
 
 int Dictionary::getFrequency(const int *word, int length) const {
diff --git a/native/jni/src/dictionary.h b/native/jni/src/dictionary.h
index 26edc4f..121cf05 100644
--- a/native/jni/src/dictionary.h
+++ b/native/jni/src/dictionary.h
@@ -41,16 +41,15 @@
     const static int KIND_SHORTCUT = 7; // A shortcut
     const static int KIND_PREDICTION = 8; // A prediction (== a suggestion with no input)
 
-    Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust, int maxWordLength,
-            int maxWords, int maxPredictions);
+    Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust);
 
     int getSuggestions(ProximityInfo *proximityInfo, void *traverseSession, int *xcoordinates,
-            int *ycoordinates, int *times, int *pointerIds, int *codes, int codesSize,
-            int *prevWordChars, int prevWordLength, int commitPoint, bool isGesture,
+            int *ycoordinates, int *times, int *pointerIds, int *inputCodePoints, int inputSize,
+            int *prevWordCodePoints, int prevWordLength, int commitPoint, bool isGesture,
             bool useFullEditDistance, int *outWords, int *frequencies, int *spaceIndices,
             int *outputTypes) const;
 
-    int getBigrams(const int *word, int length, int *codes, int codesSize, int *outWords,
+    int getBigrams(const int *word, int length, int *inputCodePoints, int inputSize, int *outWords,
             int *frequencies, int *outputTypes) const;
 
     int getFrequency(const int *word, int length) const;
diff --git a/native/jni/src/geometry_utils.h b/native/jni/src/geometry_utils.h
index 4060a7b..4bff80f 100644
--- a/native/jni/src/geometry_utils.h
+++ b/native/jni/src/geometry_utils.h
@@ -21,8 +21,6 @@
 
 #include "defines.h"
 
-#define DEBUG_DECODER false
-
 #define M_PI_F 3.14159265f
 #define ROUND_FLOAT_10000(f) ((f) < 1000.0f && (f) > 0.001f) \
         ? (floorf((f) * 10000.0f) / 10000.0f) : (f)
@@ -36,19 +34,8 @@
     return SQUARE_FLOAT(x1 - x2) + SQUARE_FLOAT(y1 - y2);
 }
 
-static inline float getNormalizedSquaredDistanceFloat(const float x1, const float y1,
-        const float x2, const float y2, const float scale) {
-    return getSquaredDistanceFloat(x1, y1, x2, y2) / SQUARE_FLOAT(scale);
-}
-
-static inline float getDistanceFloat(const float x1, const float y1, const float x2,
-        const float y2) {
-    return hypotf(x1 - x2, y1 - y2);
-}
-
 static AK_FORCE_INLINE int getDistanceInt(const int x1, const int y1, const int x2, const int y2) {
-    return static_cast<int>(getDistanceFloat(static_cast<float>(x1), static_cast<float>(y1),
-            static_cast<float>(x2), static_cast<float>(y2)));
+    return static_cast<int>(hypotf(static_cast<float>(x1 - x2), static_cast<float>(y1 - y2)));
 }
 
 static AK_FORCE_INLINE float getAngle(const int x1, const int y1, const int x2, const int y2) {
diff --git a/native/jni/src/proximity_info.cpp b/native/jni/src/proximity_info.cpp
index 8ad9c77..9b99554 100644
--- a/native/jni/src/proximity_info.cpp
+++ b/native/jni/src/proximity_info.cpp
@@ -144,7 +144,7 @@
     const float touchX = static_cast<float>(x);
     const float touchY = static_cast<float>(y);
     const float keyWidth = static_cast<float>(getMostCommonKeyWidth());
-    return getNormalizedSquaredDistanceFloat(centerX, centerY, touchX, touchY, keyWidth);
+    return getSquaredDistanceFloat(centerX, centerY, touchX, touchY) / SQUARE_FLOAT(keyWidth);
 }
 
 int ProximityInfo::squaredDistanceToEdge(const int keyId, const int x, const int y) const {
diff --git a/native/jni/src/proximity_info_state.cpp b/native/jni/src/proximity_info_state.cpp
index 5362d69..aa02929 100644
--- a/native/jni/src/proximity_info_state.cpp
+++ b/native/jni/src/proximity_info_state.cpp
@@ -20,6 +20,7 @@
 #define LOG_TAG "LatinIME: proximity_info_state.cpp"
 
 #include "defines.h"
+#include "geometry_utils.h"
 #include "proximity_info.h"
 #include "proximity_info_state.h"
 
@@ -100,7 +101,7 @@
         mTimes.clear();
         mInputIndice.clear();
         mLengthCache.clear();
-        mDistanceCache.clear();
+        mDistanceCache_G.clear();
         mNearKeysVector.clear();
         mSearchKeysVector.clear();
         mSpeedRates.clear();
@@ -209,7 +210,7 @@
         const int keyCount = mProximityInfo->getKeyCount();
         mNearKeysVector.resize(mSampledInputSize);
         mSearchKeysVector.resize(mSampledInputSize);
-        mDistanceCache.resize(mSampledInputSize * keyCount);
+        mDistanceCache_G.resize(mSampledInputSize * keyCount);
         for (int i = lastSavedInputSize; i < mSampledInputSize; ++i) {
             mNearKeysVector[i].reset();
             mSearchKeysVector[i].reset();
@@ -220,7 +221,7 @@
                 const int y = mSampledInputYs[i];
                 const float normalizedSquaredDistance =
                         mProximityInfo->getNormalizedSquaredDistanceFromCenterFloatG(k, x, y);
-                mDistanceCache[index] = normalizedSquaredDistance;
+                mDistanceCache_G[index] = normalizedSquaredDistance;
                 if (normalizedSquaredDistance < NEAR_KEY_NORMALIZED_SQUARED_THRESHOLD) {
                     mNearKeysVector[i][k] = true;
                 }
@@ -486,7 +487,7 @@
             // Assuming the cache is invalid if the previous input size is larger than the new one.
             return false;
         }
-        for (int i = 0; i < mSampledInputSize && i < MAX_WORD_LENGTH_INTERNAL; ++i) {
+        for (int i = 0; i < mSampledInputSize && i < MAX_WORD_LENGTH; ++i) {
             if (xCoordinates[i] != mSampledInputXs[i]
                     || yCoordinates[i] != mSampledInputYs[i]) {
                 return false;
@@ -685,7 +686,7 @@
     const int keyId = mProximityInfo->getKeyIndexOf(codePoint);
     if (keyId != NOT_AN_INDEX) {
         const int index = inputIndex * mProximityInfo->getKeyCount() + keyId;
-        return min(mDistanceCache[index] * scale, mMaxPointToKeyLength);
+        return min(mDistanceCache_G[index] * scale, mMaxPointToKeyLength);
     }
     if (isSkippableCodePoint(codePoint)) {
         return 0.0f;
@@ -694,7 +695,7 @@
     return MAX_POINT_TO_KEY_LENGTH;
 }
 
-float ProximityInfoState::getPointToKeyLength(const int inputIndex, const int codePoint) const {
+float ProximityInfoState::getPointToKeyLength_G(const int inputIndex, const int codePoint) const {
     return getPointToKeyLength(inputIndex, codePoint, 1.0f);
 }
 
@@ -705,7 +706,7 @@
         const int inputIndex, const int keyId, const float scale) const {
     if (keyId != NOT_AN_INDEX) {
         const int index = inputIndex * mProximityInfo->getKeyCount() + keyId;
-        return min(mDistanceCache[index] * scale, mMaxPointToKeyLength);
+        return min(mDistanceCache_G[index] * scale, mMaxPointToKeyLength);
     }
     // If the char is not a key on the keyboard then return the max length.
     return static_cast<float>(MAX_POINT_TO_KEY_LENGTH);
@@ -1184,7 +1185,7 @@
     int index = 0;
     float sumLogProbability = 0.0f;
     // TODO: Current implementation is greedy algorithm. DP would be efficient for many cases.
-    for (int i = 0; i < mSampledInputSize && index < MAX_WORD_LENGTH_INTERNAL - 1; ++i) {
+    for (int i = 0; i < mSampledInputSize && index < MAX_WORD_LENGTH - 1; ++i) {
         float minLogProbability = static_cast<float>(MAX_POINT_TO_KEY_LENGTH);
         int character = NOT_AN_INDEX;
         for (hash_map_compat<int, float>::const_iterator it = mCharProbabilities[i].begin();
diff --git a/native/jni/src/proximity_info_state.h b/native/jni/src/proximity_info_state.h
index 10e74a0..d747bae 100644
--- a/native/jni/src/proximity_info_state.h
+++ b/native/jni/src/proximity_info_state.h
@@ -24,7 +24,6 @@
 
 #include "char_utils.h"
 #include "defines.h"
-#include "geometry_utils.h"
 #include "hash_map_compat.h"
 
 namespace latinime {
@@ -59,7 +58,7 @@
               mHasTouchPositionCorrectionData(false), mMostCommonKeyWidthSquare(0), mLocaleStr(),
               mKeyCount(0), mCellHeight(0), mCellWidth(0), mGridHeight(0), mGridWidth(0),
               mIsContinuationPossible(false), mSampledInputXs(), mSampledInputYs(), mTimes(),
-              mInputIndice(), mLengthCache(), mBeelineSpeedPercentiles(), mDistanceCache(),
+              mInputIndice(), mLengthCache(), mBeelineSpeedPercentiles(), mDistanceCache_G(),
               mSpeedRates(), mDirections(), mCharProbabilities(), mNearKeysVector(),
               mSearchKeysVector(), mTouchPositionCorrectionEnabled(false), mSampledInputSize(0) {
         memset(mInputCodes, 0, sizeof(mInputCodes));
@@ -158,7 +157,7 @@
     float getPointToKeyByIdLength(const int inputIndex, const int keyId, const float scale) const;
     float getPointToKeyByIdLength(const int inputIndex, const int keyId) const;
     float getPointToKeyLength(const int inputIndex, const int codePoint, const float scale) const;
-    float getPointToKeyLength(const int inputIndex, const int codePoint) const;
+    float getPointToKeyLength_G(const int inputIndex, const int codePoint) const;
 
     ProximityType getMatchedProximityId(const int index, const int c,
             const bool checkProximityChars, int *proximityIndex = 0) const;
@@ -275,7 +274,7 @@
     std::vector<int> mInputIndice;
     std::vector<int> mLengthCache;
     std::vector<int> mBeelineSpeedPercentiles;
-    std::vector<float> mDistanceCache;
+    std::vector<float> mDistanceCache_G;
     std::vector<float> mSpeedRates;
     std::vector<float> mDirections;
     // probabilities of skipping or mapping to a key for each point.
@@ -290,10 +289,10 @@
     // inputs including the current input point.
     std::vector<NearKeycodesSet> mSearchKeysVector;
     bool mTouchPositionCorrectionEnabled;
-    int mInputCodes[MAX_PROXIMITY_CHARS_SIZE_INTERNAL * MAX_WORD_LENGTH_INTERNAL];
-    int mNormalizedSquaredDistances[MAX_PROXIMITY_CHARS_SIZE_INTERNAL * MAX_WORD_LENGTH_INTERNAL];
+    int mInputCodes[MAX_PROXIMITY_CHARS_SIZE_INTERNAL * MAX_WORD_LENGTH];
+    int mNormalizedSquaredDistances[MAX_PROXIMITY_CHARS_SIZE_INTERNAL * MAX_WORD_LENGTH];
     int mSampledInputSize;
-    int mPrimaryInputWord[MAX_WORD_LENGTH_INTERNAL];
+    int mPrimaryInputWord[MAX_WORD_LENGTH];
 };
 } // namespace latinime
 #endif // LATINIME_PROXIMITY_INFO_STATE_H
diff --git a/native/jni/src/suggest/gesture_suggest.cpp b/native/jni/src/suggest/gesture_suggest.cpp
index 2a604b8..fce5621 100644
--- a/native/jni/src/suggest/gesture_suggest.cpp
+++ b/native/jni/src/suggest/gesture_suggest.cpp
@@ -17,7 +17,7 @@
 #include "gesture_suggest.h"
 
 namespace latinime {
-    SuggestInterface *(*GestureSuggest::sGestureSuggestFactoryMethod)(int, int) = 0;
+    SuggestInterface *(*GestureSuggest::sGestureSuggestFactoryMethod)() = 0;
 
     GestureSuggest::~GestureSuggest() {
         delete mSuggestInterface;
diff --git a/native/jni/src/suggest/gesture_suggest.h b/native/jni/src/suggest/gesture_suggest.h
index e4af03f..82c3a69 100644
--- a/native/jni/src/suggest/gesture_suggest.h
+++ b/native/jni/src/suggest/gesture_suggest.h
@@ -26,37 +26,35 @@
 
 class GestureSuggest : public SuggestInterface {
  public:
-    GestureSuggest(const int maxWordLength, const int maxWords)
-            : mSuggestInterface(getGestureSuggestInstance(maxWordLength, maxWords)) {
-    }
+    GestureSuggest() : mSuggestInterface(getGestureSuggestInstance()) {}
 
     virtual ~GestureSuggest();
 
     int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs, int *inputYs,
-            int *times, int *pointerIds, int *codes, int inputSize, int commitPoint, int *outWords,
-            int *frequencies, int *outputIndices, int *outputTypes) const {
+            int *times, int *pointerIds, int *inputCodePoints, int inputSize, int commitPoint,
+            int *outWords, int *frequencies, int *outputIndices, int *outputTypes) const {
         if (!mSuggestInterface) {
             return 0;
         }
         return mSuggestInterface->getSuggestions(pInfo, traverseSession, inputXs, inputYs, times,
-                pointerIds, codes, inputSize, commitPoint, outWords, frequencies, outputIndices,
-                outputTypes);
+                pointerIds, inputCodePoints, inputSize, commitPoint, outWords, frequencies,
+                outputIndices, outputTypes);
     }
 
-    static void setGestureSuggestFactoryMethod(SuggestInterface *(*factoryMethod)(int, int)) {
+    static void setGestureSuggestFactoryMethod(SuggestInterface *(*factoryMethod)()) {
         sGestureSuggestFactoryMethod = factoryMethod;
     }
 
  private:
-    DISALLOW_IMPLICIT_CONSTRUCTORS(GestureSuggest);
-    static SuggestInterface *getGestureSuggestInstance(int maxWordLength, int maxWords) {
+    DISALLOW_COPY_AND_ASSIGN(GestureSuggest);
+    static SuggestInterface *getGestureSuggestInstance() {
         if (!sGestureSuggestFactoryMethod) {
             return 0;
         }
-        return sGestureSuggestFactoryMethod(maxWordLength, maxWords);
+        return sGestureSuggestFactoryMethod();
     }
 
-    static SuggestInterface *(*sGestureSuggestFactoryMethod)(int, int);
+    static SuggestInterface *(*sGestureSuggestFactoryMethod)();
     SuggestInterface *mSuggestInterface;
 };
 } // namespace latinime
diff --git a/native/jni/src/suggest/suggest_interface.h b/native/jni/src/suggest/suggest_interface.h
index 0fb5426..0bb85d7 100644
--- a/native/jni/src/suggest/suggest_interface.h
+++ b/native/jni/src/suggest/suggest_interface.h
@@ -26,8 +26,9 @@
 class SuggestInterface {
  public:
     virtual int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs,
-            int *inputYs, int *times, int *pointerIds, int *codes, int inputSize, int commitPoint,
-            int *outWords, int *frequencies, int *outputIndices, int *outputTypes) const = 0;
+            int *inputYs, int *times, int *pointerIds, int *inputCodePoints, int inputSize,
+            int commitPoint, int *outWords, int *frequencies, int *outputIndices,
+            int *outputTypes) const = 0;
     SuggestInterface() {}
     virtual ~SuggestInterface() {}
  private:
diff --git a/native/jni/src/suggest/typing_suggest.cpp b/native/jni/src/suggest/typing_suggest.cpp
index 40d4a98..56bd5b6 100644
--- a/native/jni/src/suggest/typing_suggest.cpp
+++ b/native/jni/src/suggest/typing_suggest.cpp
@@ -17,7 +17,7 @@
 #include "typing_suggest.h"
 
 namespace latinime {
-    SuggestInterface *(*TypingSuggest::sTypingSuggestFactoryMethod)(int, int) = 0;
+    SuggestInterface *(*TypingSuggest::sTypingSuggestFactoryMethod)() = 0;
 
     TypingSuggest::~TypingSuggest() {
         delete mSuggestInterface;
diff --git a/native/jni/src/suggest/typing_suggest.h b/native/jni/src/suggest/typing_suggest.h
index 9de4158..678037a 100644
--- a/native/jni/src/suggest/typing_suggest.h
+++ b/native/jni/src/suggest/typing_suggest.h
@@ -26,37 +26,35 @@
 
 class TypingSuggest : public SuggestInterface {
  public:
-    TypingSuggest(const int maxWordLength, const int maxWords)
-            : mSuggestInterface(getTypingSuggestInstance(maxWordLength, maxWords)) {
-    }
+    TypingSuggest() : mSuggestInterface(getTypingSuggestInstance()) {}
 
     virtual ~TypingSuggest();
 
     int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs, int *inputYs,
-            int *times, int *pointerIds, int *codes, int inputSize, int commitPoint, int *outWords,
-            int *frequencies, int *outputIndices, int *outputTypes) const {
+            int *times, int *pointerIds, int *inputCodePoints, int inputSize, int commitPoint,
+            int *outWords, int *frequencies, int *outputIndices, int *outputTypes) const {
         if (!mSuggestInterface) {
             return 0;
         }
         return mSuggestInterface->getSuggestions(pInfo, traverseSession, inputXs, inputYs, times,
-                pointerIds, codes, inputSize, commitPoint, outWords, frequencies, outputIndices,
-                outputTypes);
+                pointerIds, inputCodePoints, inputSize, commitPoint, outWords, frequencies,
+                outputIndices, outputTypes);
     }
 
-    static void setTypingSuggestFactoryMethod(SuggestInterface *(*factoryMethod)(int, int)) {
+    static void setTypingSuggestFactoryMethod(SuggestInterface *(*factoryMethod)()) {
         sTypingSuggestFactoryMethod = factoryMethod;
     }
 
  private:
-    DISALLOW_IMPLICIT_CONSTRUCTORS(TypingSuggest);
-    static SuggestInterface *getTypingSuggestInstance(int maxWordLength, int maxWords) {
+    DISALLOW_COPY_AND_ASSIGN(TypingSuggest);
+    static SuggestInterface *getTypingSuggestInstance() {
         if (!sTypingSuggestFactoryMethod) {
             return 0;
         }
-        return sTypingSuggestFactoryMethod(maxWordLength, maxWords);
+        return sTypingSuggestFactoryMethod();
     }
 
-    static SuggestInterface *(*sTypingSuggestFactoryMethod)(int, int);
+    static SuggestInterface *(*sTypingSuggestFactoryMethod)();
     SuggestInterface *mSuggestInterface;
 };
 } // namespace latinime
diff --git a/native/jni/src/suggest_utils.h b/native/jni/src/suggest_utils.h
new file mode 100644
index 0000000..42cc5de
--- /dev/null
+++ b/native/jni/src/suggest_utils.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef LATINIME_SUGGEST_UTILS_H
+#define LATINIME_SUGGEST_UTILS_H
+
+#include "defines.h"
+#include "proximity_info_state.h"
+
+namespace latinime {
+class SuggestUtils {
+ public:
+    static float getDistanceScalingFactor(const float normalizedSquaredDistance) {
+        if (normalizedSquaredDistance < 0.0f) {
+            return -1.0f;
+        }
+        // Promote or demote the score according to the distance from the sweet spot
+        static const float A = ZERO_DISTANCE_PROMOTION_RATE / 100.0f;
+        static const float B = 1.0f;
+        static const float C = 0.5f;
+        static const float MIN = 0.3f;
+        static const float R1 = NEUTRAL_SCORE_SQUARED_RADIUS;
+        static const float R2 = HALF_SCORE_SQUARED_RADIUS;
+        const float x = normalizedSquaredDistance / static_cast<float>(
+                ProximityInfoState::NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR);
+        const float factor = max((x < R1)
+                ? (A * (R1 - x) + B * x) / R1
+                : (B * (R2 - x) + C * (x - R1)) / (R2 - R1), MIN);
+        // factor is a piecewise linear function like:
+        // A -_                  .
+        //     ^-_               .
+        // B      \              .
+        //         \_            .
+        // C         ------------.
+        //                       .
+        // 0   R1 R2             .
+        return factor;
+    }
+
+ private:
+    DISALLOW_IMPLICIT_CONSTRUCTORS(SuggestUtils);
+};
+} // namespace latinime
+#endif // LATINIME_SUGGEST_UTILS_H
diff --git a/native/jni/src/terminal_attributes.h b/native/jni/src/terminal_attributes.h
index 6c2e0dc..a8cc03b 100644
--- a/native/jni/src/terminal_attributes.h
+++ b/native/jni/src/terminal_attributes.h
@@ -30,10 +30,6 @@
 class TerminalAttributes {
  public:
     class ShortcutIterator {
-        const uint8_t *const mDict;
-        int mPos;
-        bool mHasNextShortcutTarget;
-
      public:
         ShortcutIterator(const uint8_t *dict, const int pos, const uint8_t flags)
                 : mDict(dict), mPos(pos),
@@ -50,7 +46,7 @@
             const int shortcutFlags = BinaryFormat::getFlagsAndForwardPointer(mDict, &mPos);
             mHasNextShortcutTarget = 0 != (shortcutFlags & BinaryFormat::FLAG_ATTRIBUTE_HAS_NEXT);
             unsigned int i;
-            for (i = 0; i < MAX_WORD_LENGTH_INTERNAL; ++i) {
+            for (i = 0; i < MAX_WORD_LENGTH; ++i) {
                 const int codePoint = BinaryFormat::getCodePointAndForwardPointer(mDict, &mPos);
                 if (NOT_A_CODE_POINT == codePoint) break;
                 outWord[i] = codePoint;
@@ -58,6 +54,11 @@
             *outFreq = BinaryFormat::getAttributeFrequencyFromFlags(shortcutFlags);
             return i;
         }
+
+     private:
+        const uint8_t *const mDict;
+        int mPos;
+        bool mHasNextShortcutTarget;
     };
 
     TerminalAttributes(const uint8_t *const dict, const uint8_t flags, const int pos)
diff --git a/native/jni/src/unigram_dictionary.cpp b/native/jni/src/unigram_dictionary.cpp
index 0a14425..0b18e78 100644
--- a/native/jni/src/unigram_dictionary.cpp
+++ b/native/jni/src/unigram_dictionary.cpp
@@ -40,10 +40,9 @@
         { 'o', 'e', 0x0153 } }; // U+0153 : LATIN SMALL LIGATURE OE
 
 // TODO: check the header
-UnigramDictionary::UnigramDictionary(const uint8_t *const streamStart, int maxWordLength,
-        int maxWords, const unsigned int flags)
-        : DICT_ROOT(streamStart), MAX_WORD_LENGTH(maxWordLength), MAX_WORDS(maxWords),
-          ROOT_POS(0), MAX_DIGRAPH_SEARCH_DEPTH(DEFAULT_MAX_DIGRAPH_SEARCH_DEPTH), FLAGS(flags) {
+UnigramDictionary::UnigramDictionary(const uint8_t *const streamStart, const unsigned int flags)
+        : DICT_ROOT(streamStart), ROOT_POS(0),
+          MAX_DIGRAPH_SEARCH_DEPTH(DEFAULT_MAX_DIGRAPH_SEARCH_DEPTH), FLAGS(flags) {
     if (DEBUG_DICT) {
         AKLOGI("UnigramDictionary - constructor");
     }
@@ -52,21 +51,17 @@
 UnigramDictionary::~UnigramDictionary() {
 }
 
-static inline int getCodesBufferSize(const int *codes, const int codesSize) {
-    return sizeof(*codes) * codesSize;
-}
-
 // TODO: This needs to take a const int* and not tinker with its contents
 static void addWord(int *word, int length, int frequency, WordsPriorityQueue *queue, int type) {
     queue->push(frequency, word, length, type);
 }
 
 // Return the replacement code point for a digraph, or 0 if none.
-int UnigramDictionary::getDigraphReplacement(const int *codes, const int i, const int codesSize,
+int UnigramDictionary::getDigraphReplacement(const int *codes, const int i, const int inputSize,
         const digraph_t *const digraphs, const unsigned int digraphsSize) const {
 
     // There can't be a digraph if we don't have at least 2 characters to examine
-    if (i + 2 > codesSize) return false;
+    if (i + 2 > inputSize) return false;
 
     // Search for the first char of some digraph
     int lastDigraphIndex = -1;
@@ -87,7 +82,7 @@
 
 // Mostly the same arguments as the non-recursive version, except:
 // codes is the original value. It points to the start of the work buffer, and gets passed as is.
-// codesSize is the size of the user input (thus, it is the size of codesSrc).
+// inputSize is the size of the user input (thus, it is the size of codesSrc).
 // codesDest is the current point in the work buffer.
 // codesSrc is the current point in the user-input, original, content-unmodified buffer.
 // codesRemain is the remaining size in codesSrc.
@@ -167,49 +162,49 @@
 // bigramFilter is a bloom filter for fast rejection: see functions setInFilter and isInFilter
 // in bigram_dictionary.cpp
 int UnigramDictionary::getSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-        const int *ycoordinates, const int *codes, const int codesSize,
+        const int *ycoordinates, const int *inputCodePoints, const int inputSize,
         const std::map<int, int> *bigramMap, const uint8_t *bigramFilter,
         const bool useFullEditDistance, int *outWords, int *frequencies, int *outputTypes) const {
-    WordsPriorityQueuePool queuePool(MAX_WORDS, SUB_QUEUE_MAX_WORDS, MAX_WORD_LENGTH);
+    WordsPriorityQueuePool queuePool(MAX_RESULTS, SUB_QUEUE_MAX_WORDS);
     queuePool.clearAll();
     Correction masterCorrection;
     masterCorrection.resetCorrection();
     if (BinaryFormat::REQUIRES_GERMAN_UMLAUT_PROCESSING & FLAGS)
     { // Incrementally tune the word and try all possibilities
-        int codesBuffer[getCodesBufferSize(codes, codesSize)];
-        int xCoordinatesBuffer[codesSize];
-        int yCoordinatesBuffer[codesSize];
+        int codesBuffer[sizeof(*inputCodePoints) * inputSize];
+        int xCoordinatesBuffer[inputSize];
+        int yCoordinatesBuffer[inputSize];
         getWordWithDigraphSuggestionsRec(proximityInfo, xcoordinates, ycoordinates, codesBuffer,
-                xCoordinatesBuffer, yCoordinatesBuffer, codesSize, bigramMap, bigramFilter,
-                useFullEditDistance, codes, codesSize, 0, codesBuffer, &masterCorrection,
+                xCoordinatesBuffer, yCoordinatesBuffer, inputSize, bigramMap, bigramFilter,
+                useFullEditDistance, inputCodePoints, inputSize, 0, codesBuffer, &masterCorrection,
                 &queuePool, GERMAN_UMLAUT_DIGRAPHS, NELEMS(GERMAN_UMLAUT_DIGRAPHS));
     } else if (BinaryFormat::REQUIRES_FRENCH_LIGATURES_PROCESSING & FLAGS) {
-        int codesBuffer[getCodesBufferSize(codes, codesSize)];
-        int xCoordinatesBuffer[codesSize];
-        int yCoordinatesBuffer[codesSize];
+        int codesBuffer[sizeof(*inputCodePoints) * inputSize];
+        int xCoordinatesBuffer[inputSize];
+        int yCoordinatesBuffer[inputSize];
         getWordWithDigraphSuggestionsRec(proximityInfo, xcoordinates, ycoordinates, codesBuffer,
-                xCoordinatesBuffer, yCoordinatesBuffer, codesSize, bigramMap, bigramFilter,
-                useFullEditDistance, codes, codesSize, 0, codesBuffer, &masterCorrection,
+                xCoordinatesBuffer, yCoordinatesBuffer, inputSize, bigramMap, bigramFilter,
+                useFullEditDistance, inputCodePoints, inputSize, 0, codesBuffer, &masterCorrection,
                 &queuePool, FRENCH_LIGATURES_DIGRAPHS, NELEMS(FRENCH_LIGATURES_DIGRAPHS));
     } else { // Normal processing
-        getWordSuggestions(proximityInfo, xcoordinates, ycoordinates, codes, codesSize,
+        getWordSuggestions(proximityInfo, xcoordinates, ycoordinates, inputCodePoints, inputSize,
                 bigramMap, bigramFilter, useFullEditDistance, &masterCorrection, &queuePool);
     }
 
     PROF_START(20);
     if (DEBUG_DICT) {
         float ns = queuePool.getMasterQueue()->getHighestNormalizedScore(
-                masterCorrection.getPrimaryInputWord(), codesSize, 0, 0, 0);
+                masterCorrection.getPrimaryInputWord(), inputSize, 0, 0, 0);
         ns += 0;
         AKLOGI("Max normalized score = %f", ns);
     }
     const int suggestedWordsCount =
             queuePool.getMasterQueue()->outputSuggestions(masterCorrection.getPrimaryInputWord(),
-                    codesSize, frequencies, outWords, outputTypes);
+                    inputSize, frequencies, outWords, outputTypes);
 
     if (DEBUG_DICT) {
         float ns = queuePool.getMasterQueue()->getHighestNormalizedScore(
-                masterCorrection.getPrimaryInputWord(), codesSize, 0, 0, 0);
+                masterCorrection.getPrimaryInputWord(), inputSize, 0, 0, 0);
         ns += 0;
         AKLOGI("Returning %d words", suggestedWordsCount);
         /// Print the returned words
@@ -227,7 +222,7 @@
 }
 
 void UnigramDictionary::getWordSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-        const int *ycoordinates, const int *codes, const int inputSize,
+        const int *ycoordinates, const int *inputCodePoints, const int inputSize,
         const std::map<int, int> *bigramMap, const uint8_t *bigramFilter,
         const bool useFullEditDistance, Correction *correction, WordsPriorityQueuePool *queuePool)
         const {
@@ -236,8 +231,8 @@
     PROF_END(0);
 
     PROF_START(1);
-    getOneWordSuggestions(proximityInfo, xcoordinates, ycoordinates, codes, bigramMap, bigramFilter,
-            useFullEditDistance, inputSize, correction, queuePool);
+    getOneWordSuggestions(proximityInfo, xcoordinates, ycoordinates, inputCodePoints, bigramMap,
+            bigramFilter, useFullEditDistance, inputSize, correction, queuePool);
     PROF_END(1);
 
     PROF_START(2);
@@ -262,7 +257,7 @@
     // Multiple word suggestions
     if (SUGGEST_MULTIPLE_WORDS
             && inputSize >= MIN_USER_TYPED_LENGTH_FOR_MULTIPLE_WORD_SUGGESTION) {
-        getSplitMultipleWordsSuggestions(proximityInfo, xcoordinates, ycoordinates, codes,
+        getSplitMultipleWordsSuggestions(proximityInfo, xcoordinates, ycoordinates, inputCodePoints,
                 useFullEditDistance, inputSize, correction, queuePool,
                 hasAutoCorrectionCandidate);
     }
@@ -398,10 +393,10 @@
             // so that the insert order is protected inside the queue for words
             // with the same score. For the moment we use -1 to make sure the shortcut will
             // never be in front of the word.
-            int shortcutTarget[MAX_WORD_LENGTH_INTERNAL];
+            int shortcutTarget[MAX_WORD_LENGTH];
             int shortcutFrequency;
             const int shortcutTargetStringLength = iterator.getNextShortcutTarget(
-                    MAX_WORD_LENGTH_INTERNAL, shortcutTarget, &shortcutFrequency);
+                    MAX_WORD_LENGTH, shortcutTarget, &shortcutFrequency);
             int shortcutScore;
             int kind;
             if (shortcutFrequency == BinaryFormat::WHITELIST_SHORTCUT_FREQUENCY
@@ -487,7 +482,7 @@
     initSuggestions(proximityInfo, xcoordinates, ycoordinates, codes,
             inputSize, correction);
 
-    int word[MAX_WORD_LENGTH_INTERNAL];
+    int word[MAX_WORD_LENGTH];
     int freq = getMostFrequentWordLike(
             inputWordStartPos, inputWordLength, correction, word);
     if (freq > 0) {
@@ -761,13 +756,13 @@
 // that is, everything that only differs by case/accents.
 int UnigramDictionary::getMostFrequentWordLikeInner(const int *const inWord, const int inputSize,
         int *outWord) const {
-    int newWord[MAX_WORD_LENGTH_INTERNAL];
+    int newWord[MAX_WORD_LENGTH];
     int depth = 0;
     int maxFreq = -1;
     const uint8_t *const root = DICT_ROOT;
-    int stackChildCount[MAX_WORD_LENGTH_INTERNAL];
-    int stackInputIndex[MAX_WORD_LENGTH_INTERNAL];
-    int stackSiblingPos[MAX_WORD_LENGTH_INTERNAL];
+    int stackChildCount[MAX_WORD_LENGTH];
+    int stackInputIndex[MAX_WORD_LENGTH];
+    int stackSiblingPos[MAX_WORD_LENGTH];
 
     int startPos = 0;
     stackChildCount[0] = BinaryFormat::getGroupCountAndForwardPointer(root, &startPos);
diff --git a/native/jni/src/unigram_dictionary.h b/native/jni/src/unigram_dictionary.h
index f5850b4..502bf47 100644
--- a/native/jni/src/unigram_dictionary.h
+++ b/native/jni/src/unigram_dictionary.h
@@ -39,12 +39,11 @@
     static const int FLAG_MULTIPLE_SUGGEST_ABORT = 0;
     static const int FLAG_MULTIPLE_SUGGEST_SKIP = 1;
     static const int FLAG_MULTIPLE_SUGGEST_CONTINUE = 2;
-    UnigramDictionary(const uint8_t *const streamStart, int maxWordLength, int maxWords,
-            const unsigned int flags);
+    UnigramDictionary(const uint8_t *const streamStart, const unsigned int flags);
     int getFrequency(const int *const inWord, const int length) const;
     int getBigramPosition(int pos, int *word, int offset, int length) const;
     int getSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-            const int *ycoordinates, const int *codes, const int codesSize,
+            const int *ycoordinates, const int *inputCodePoints, const int inputSize,
             const std::map<int, int> *bigramMap, const uint8_t *bigramFilter,
             const bool useFullEditDistance, int *outWords, int *frequencies,
             int *outputTypes) const;
@@ -53,11 +52,11 @@
  private:
     DISALLOW_IMPLICIT_CONSTRUCTORS(UnigramDictionary);
     void getWordSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-            const int *ycoordinates, const int *codes, const int inputSize,
+            const int *ycoordinates, const int *inputCodePoints, const int inputSize,
             const std::map<int, int> *bigramMap, const uint8_t *bigramFilter,
             const bool useFullEditDistance, Correction *correction,
             WordsPriorityQueuePool *queuePool) const;
-    int getDigraphReplacement(const int *codes, const int i, const int codesSize,
+    int getDigraphReplacement(const int *codes, const int i, const int inputSize,
             const digraph_t *const digraphs, const unsigned int digraphsSize) const;
     void getWordWithDigraphSuggestionsRec(ProximityInfo *proximityInfo, const int *xcoordinates,
             const int *ycoordinates, const int *codesBuffer, int *xCoordinatesBuffer,
@@ -67,7 +66,7 @@
             WordsPriorityQueuePool *queuePool, const digraph_t *const digraphs,
             const unsigned int digraphsSize) const;
     void initSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-            const int *ycoordinates, const int *codes, const int codesSize,
+            const int *ycoordinates, const int *codes, const int inputSize,
             Correction *correction) const;
     void getOneWordSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
             const int *ycoordinates, const int *codes, const std::map<int, int> *bigramMap,
@@ -109,8 +108,6 @@
             int *outputWord) const;
 
     const uint8_t *const DICT_ROOT;
-    const int MAX_WORD_LENGTH;
-    const int MAX_WORDS;
     const int ROOT_POS;
     const int MAX_DIGRAPH_SEARCH_DEPTH;
     const int FLAGS;
diff --git a/native/jni/src/words_priority_queue.h b/native/jni/src/words_priority_queue.h
index 84b4b48..7aab1e0 100644
--- a/native/jni/src/words_priority_queue.h
+++ b/native/jni/src/words_priority_queue.h
@@ -27,10 +27,9 @@
 
 class WordsPriorityQueue {
  public:
-    class SuggestedWord {
-     public:
+    struct SuggestedWord {
         int mScore;
-        int mWord[MAX_WORD_LENGTH_INTERNAL];
+        int mWord[MAX_WORD_LENGTH];
         int mWordLength;
         bool mUsed;
         int mType;
@@ -44,11 +43,10 @@
         }
     };
 
-    WordsPriorityQueue(int maxWords, int maxWordLength)
-            : mSuggestions(), MAX_WORDS(static_cast<unsigned int>(maxWords)),
-              MAX_WORD_LENGTH(static_cast<unsigned int>(maxWordLength)),
-              mSuggestedWords(new SuggestedWord[maxWordLength]), mHighestSuggestedWord(0) {
-        for (int i = 0; i < maxWordLength; ++i) {
+    WordsPriorityQueue(int maxWords)
+            : mSuggestions(), MAX_WORDS(maxWords),
+              mSuggestedWords(new SuggestedWord[MAX_WORD_LENGTH]), mHighestSuggestedWord(0) {
+        for (int i = 0; i < MAX_WORD_LENGTH; ++i) {
             mSuggestedWords[i].mUsed = false;
         }
     }
@@ -171,7 +169,6 @@
             wordComparator> Suggestions;
     Suggestions mSuggestions;
     const int MAX_WORDS;
-    const int MAX_WORD_LENGTH;
     SuggestedWord *mSuggestedWords;
     SuggestedWord *mHighestSuggestedWord;
 };
diff --git a/native/jni/src/words_priority_queue_pool.h b/native/jni/src/words_priority_queue_pool.h
index f7c08fb..cfe7ede 100644
--- a/native/jni/src/words_priority_queue_pool.h
+++ b/native/jni/src/words_priority_queue_pool.h
@@ -24,15 +24,14 @@
 
 class WordsPriorityQueuePool {
  public:
-    WordsPriorityQueuePool(int mainQueueMaxWords, int subQueueMaxWords, int maxWordLength)
+    WordsPriorityQueuePool(int mainQueueMaxWords, int subQueueMaxWords)
             // Note: using placement new() requires the caller to call the destructor explicitly.
-            : mMasterQueue(new(mMasterQueueBuf) WordsPriorityQueue(
-                      mainQueueMaxWords, maxWordLength)) {
+            : mMasterQueue(new(mMasterQueueBuf) WordsPriorityQueue(mainQueueMaxWords)) {
         for (int i = 0, subQueueBufOffset = 0;
                 i < MULTIPLE_WORDS_SUGGESTION_MAX_WORDS * SUB_QUEUE_MAX_COUNT;
                 ++i, subQueueBufOffset += static_cast<int>(sizeof(WordsPriorityQueue))) {
             mSubQueues[i] = new(mSubQueueBuf + subQueueBufOffset)
-                    WordsPriorityQueue(subQueueMaxWords, maxWordLength);
+                    WordsPriorityQueue(subQueueMaxWords);
         }
     }
 
diff --git a/tests/src/com/android/inputmethod/latin/BlueUnderlineTests.java b/tests/src/com/android/inputmethod/latin/BlueUnderlineTests.java
index e2d669b..6b4d52d 100644
--- a/tests/src/com/android/inputmethod/latin/BlueUnderlineTests.java
+++ b/tests/src/com/android/inputmethod/latin/BlueUnderlineTests.java
@@ -117,7 +117,5 @@
         // Now simulate the user moving the cursor.
         SpanGetter span = new SpanGetter(mTextView.getText(), UnderlineSpan.class);
         assertNull("should not be composing, so should not have an underline span", span.mSpan);
-        span = new SpanGetter(mTextView.getText(), SuggestionSpan.class);
-        assertNull("should not be composing, so should not have an underline span", span.mSpan);
     }
 }
diff --git a/tests/src/com/android/inputmethod/latin/InputTestsBase.java b/tests/src/com/android/inputmethod/latin/InputTestsBase.java
index 8629867..a01fef2 100644
--- a/tests/src/com/android/inputmethod/latin/InputTestsBase.java
+++ b/tests/src/com/android/inputmethod/latin/InputTestsBase.java
@@ -55,8 +55,6 @@
     protected MyTextView mTextView;
     protected View mInputView;
     protected InputConnection mInputConnection;
-    private final HashMap<String, InputMethodSubtype> mSubtypeMap =
-            new HashMap<String, InputMethodSubtype>();
 
     // A helper class to ease span tests
     public static class SpanGetter {
@@ -143,7 +141,6 @@
         final boolean previousDebugSetting = setDebugMode(true);
         mLatinIME.onCreate();
         setDebugMode(previousDebugSetting);
-        initSubtypeMap();
         final EditorInfo ei = new EditorInfo();
         ei.inputType = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_AUTO_CORRECT;
         final InputConnection ic = mTextView.onCreateInputConnection(ei);
@@ -161,26 +158,6 @@
         changeLanguage("en_US");
     }
 
-    private void initSubtypeMap() {
-        final InputMethodManager imm = (InputMethodManager)mLatinIME.getSystemService(
-                Context.INPUT_METHOD_SERVICE);
-        final String packageName = mLatinIME.getPackageName();
-        // The IMEs and subtypes don't need to be enabled to run this test because IMF isn't
-        // involved here.
-        for (final InputMethodInfo imi : imm.getInputMethodList()) {
-            if (imi.getPackageName().equals(packageName)) {
-                final int subtypeCount = imi.getSubtypeCount();
-                for (int i = 0; i < subtypeCount; i++) {
-                    final InputMethodSubtype ims = imi.getSubtypeAt(i);
-                    final String locale = ims.getLocale();
-                    mSubtypeMap.put(locale, ims);
-                }
-                return;
-            }
-        }
-        fail("LatinIME is not found");
-    }
-
     // We need to run the messages added to the handler from LatinIME. The only way to do
     // that is to call Looper#loop() on the right looper, so we're going to get the looper
     // object and call #loop() here. The messages in the handler actually run on the UI
@@ -270,12 +247,8 @@
     }
 
     protected void changeLanguage(final String locale) {
-        final InputMethodSubtype subtype = mSubtypeMap.get(locale);
         mTextView.mCurrentLocale = LocaleUtils.constructLocaleFromString(locale);
-        if (subtype == null) {
-            fail("InputMethodSubtype for locale " + locale + " is not enabled");
-        }
-        SubtypeSwitcher.getInstance().onSubtypeChanged(subtype);
+        SubtypeSwitcher.getInstance().forceLocale(mTextView.mCurrentLocale);
         mLatinIME.loadKeyboard();
         mKeyboard = mLatinIME.mKeyboardSwitcher.getKeyboard();
         waitForDictionaryToBeLoaded();
diff --git a/tools/maketext/res/values-ar/donottranslate-more-keys.xml b/tools/maketext/res/values-ar/donottranslate-more-keys.xml
index c404bed..f10139e 100644
--- a/tools/maketext/res/values-ar/donottranslate-more-keys.xml
+++ b/tools/maketext/res/values-ar/donottranslate-more-keys.xml
@@ -139,6 +139,7 @@
          U+064E: "َ" ARABIC FATHA
          U+0640: "ـ" ARABIC TATWEEL -->
     <!-- In order to make Tatweel easily distinguishable from other punctuations, we use consecutive Tatweels only for its displayed label. -->
-    <string name="more_keys_for_arabic_diacritics">"!fixedColumnOrder!7,&#x0655;,&#x0654;,&#x0652;,&#x064D;,&#x064C;,&#x064B;,&#x0651;,&#x0656;,&#x0670;,&#x0653;,&#x0650;,&#x064F;,&#x064E;,&#x0640;&#x0640;&#x0640;|&#x0640;"</string>
+    <!-- Note: The space character is needed as a preceding letter to draw Arabic diacritics characters correctly. -->
+    <string name="more_keys_for_arabic_diacritics">"!fixedColumnOrder!7,&#x20;&#x0655;|&#x0655;,&#x20;&#x0654;|&#x0654;,&#x20;&#x0652;|&#x0652;,&#x20;&#x064D;|&#x064D;,&#x20;&#x064C;|&#x064C;,&#x20;&#x064B;|&#x064B;,&#x20;&#x0651;|&#x0651;,&#x20;&#x0656;|&#x0656;,&#x20;&#x0670;|&#x0670;,&#x20;&#x0653;|&#x0653;,&#x20;&#x0650;|&#x0650;,&#x20;&#x064F;|&#x064F;,&#x20;&#x064E;|&#x064E;,&#x0640;&#x0640;&#x0640;|&#x0640;"</string>
     <string name="keyhintlabel_for_arabic_diacritics">&#x0651;</string>
 </resources>
diff --git a/tools/maketext/res/values-fa/donottranslate-more-keys.xml b/tools/maketext/res/values-fa/donottranslate-more-keys.xml
index 47f21cc..6acdd41 100644
--- a/tools/maketext/res/values-fa/donottranslate-more-keys.xml
+++ b/tools/maketext/res/values-fa/donottranslate-more-keys.xml
@@ -148,6 +148,7 @@
          U+064E: "َ" ARABIC FATHA
          U+0640: "ـ" ARABIC TATWEEL -->
     <!-- In order to make Tatweel easily distinguishable from other punctuations, we use consecutive Tatweels only for its displayed label. -->
-    <string name="more_keys_for_arabic_diacritics">"!fixedColumnOrder!7,&#x0655;,&#x0652;,&#x0651;,&#x064C;,&#x064D;,&#x064B;,&#x0654;,&#x0656;,&#x0670;,&#x0653;,&#x064F;,&#x0650;,&#x064E;,&#x0640;&#x0640;&#x0640;|&#x0640;"</string>
+    <!-- Note: The space character is needed as a preceding letter to draw Arabic diacritics characters correctly. -->
+    <string name="more_keys_for_arabic_diacritics">"!fixedColumnOrder!7,&#x20;&#x0655;|&#x0655;,&#x20;&#x0652;|&#x0652;,&#x20;&#x0651;|&#x0651;,&#x20;&#x064C;|&#x064C;,&#x20;&#x064D;|&#x064D;,&#x20;&#x064B;|&#x064B;,&#x20;&#x0654;|&#x0654;,&#x20;&#x0656;|&#x0656;,&#x20;&#x0670;|&#x0670;,&#x20;&#x0653;|&#x0653;,&#x20;&#x064F;|&#x064F;,&#x20;&#x0650;|&#x0650;,&#x20;&#x064E;|&#x064E;,&#x0640;&#x0640;&#x0640;|&#x0640;"</string>
     <string name="keyhintlabel_for_arabic_diacritics">&#x064B;</string>
 </resources>
diff --git a/tools/maketext/src/com/android/inputmethod/latin/maketext/StringResourceMap.java b/tools/maketext/src/com/android/inputmethod/latin/maketext/StringResourceMap.java
index 6ceea5a..ff13342 100644
--- a/tools/maketext/src/com/android/inputmethod/latin/maketext/StringResourceMap.java
+++ b/tools/maketext/src/com/android/inputmethod/latin/maketext/StringResourceMap.java
@@ -18,6 +18,7 @@
 
 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
 import org.xml.sax.ext.DefaultHandler2;
 
 import java.io.IOException;
@@ -48,6 +49,9 @@
             parser.setProperty("http://xml.org/sax/properties/lexical-handler", handler);
             parser.parse(is, handler);
         } catch (ParserConfigurationException e) {
+        } catch (SAXParseException e) {
+            throw new RuntimeException(e.getMessage() + " at line " + e.getLineNumber()
+                    + ", column " + e.getColumnNumber());
         } catch (SAXException e) {
             throw new RuntimeException(e.getMessage());
         } catch (IOException e) {