diff --git a/java/res/values/keypress-vibration-durations.xml b/java/res/values/keypress-vibration-durations.xml
index 9ce5051..ad6bead 100644
--- a/java/res/values/keypress-vibration-durations.xml
+++ b/java/res/values/keypress-vibration-durations.xml
@@ -37,7 +37,7 @@
         <item>MODEL=(SAMSUNG-)?GT-I(930[05][NT]?|9308):MANUFACTURER=samsung,8</item>
         <item>MODEL=(SAMSUNG-)?SGH-(T999[V]?|I747[M]?|N064|N035):MANUFACTURER=samsung,8</item>
         <item>MODEL=(SAMSUNG-)?SCH-(J021|R530|I535|I939):MANUFACTURER=samsung,8</item>
-        <item>MODEL=(SAMSUNG-)?(SCL21|SC-06D|SC-03E]):MANUFACTURER=samsung,8</item>
+        <item>MODEL=(SAMSUNG-)?(SCL21|SC-06D|SC-03E):MANUFACTURER=samsung,8</item>
         <item>MODEL=(SAMSUNG-)?(SHV-210[KLS]?|SPH-L710):MANUFACTURER=samsung,8</item>
         <!-- LG Optimus G -->
         <item>MODEL=LG-E97[013]|LS970|L-01E:MANUFACTURER=LGE,15</item>
diff --git a/java/src/com/android/inputmethod/latin/AdditionalFeaturesSettingUtils.java b/java/src/com/android/inputmethod/latin/AdditionalFeaturesSettingUtils.java
new file mode 100644
index 0000000..0fdaea5
--- /dev/null
+++ b/java/src/com/android/inputmethod/latin/AdditionalFeaturesSettingUtils.java
@@ -0,0 +1,47 @@
+/*
+ * 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.latin;
+
+import com.android.inputmethodcommon.InputMethodSettingsFragment;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+/**
+ * Utility class for managing additional features settings.
+ */
+public class AdditionalFeaturesSettingUtils {
+    public static final int ADDITIONAL_FEATURES_SETTINGS_SIZE = 0;
+
+    private AdditionalFeaturesSettingUtils() {
+        // This utility class is not publicly instantiable.
+    }
+
+    public static void addAdditionalFeaturesPreferences(
+            final Context context, final InputMethodSettingsFragment settingsFragment) {
+        // do nothing.
+    }
+
+    public static void readAdditionalFeaturesPreferencesIntoArray(
+            final SharedPreferences prefs, final int[] additionalFeaturesPreferences) {
+        // do nothing.
+    }
+
+    public static int[] getAdditionalNativeSuggestOptions() {
+        return Settings.getInstance().getCurrent().mAdditionalFeaturesSettingValues;
+    }
+}
diff --git a/java/src/com/android/inputmethod/latin/BinaryDictionary.java b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
index c644a77..aad129d 100644
--- a/java/src/com/android/inputmethod/latin/BinaryDictionary.java
+++ b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
@@ -136,6 +136,8 @@
         final InputPointers ips = composer.getInputPointers();
         final int inputSize = isGesture ? ips.getPointerSize() : composerSize;
         mNativeSuggestOptions.setIsGesture(isGesture);
+        mNativeSuggestOptions.setAdditionalFeaturesOptions(
+                AdditionalFeaturesSettingUtils.getAdditionalNativeSuggestOptions());
         // proximityInfo and/or prevWordForBigrams may not be null.
         final int count = getSuggestionsNative(mNativeDict, proximityInfo.getNativeProximityInfo(),
                 getTraverseSession(sessionId).getSession(), ips.getXCoordinates(),
diff --git a/java/src/com/android/inputmethod/latin/NativeSuggestOptions.java b/java/src/com/android/inputmethod/latin/NativeSuggestOptions.java
index 4425f07..2915513 100644
--- a/java/src/com/android/inputmethod/latin/NativeSuggestOptions.java
+++ b/java/src/com/android/inputmethod/latin/NativeSuggestOptions.java
@@ -22,7 +22,8 @@
     private static final int USE_FULL_EDIT_DISTANCE = 1;
     private static final int OPTIONS_SIZE = 2;
 
-    private final int[] mOptions = new int[OPTIONS_SIZE];
+    private final int[] mOptions = new int[OPTIONS_SIZE
+            + AdditionalFeaturesSettingUtils.ADDITIONAL_FEATURES_SETTINGS_SIZE];
 
     public void setIsGesture(final boolean value) {
         setBooleanOption(IS_GESTURE, value);
@@ -32,6 +33,12 @@
         setBooleanOption(USE_FULL_EDIT_DISTANCE, value);
     }
 
+    public void setAdditionalFeaturesOptions(final int[] additionalOptions) {
+        for (int i = 0; i < additionalOptions.length; i++) {
+            setIntegerOption(OPTIONS_SIZE + i, additionalOptions[i]);
+        }
+    }
+
     public int[] getOptions() {
         return mOptions;
     }
@@ -39,4 +46,8 @@
     private void setBooleanOption(final int key, final boolean value) {
         mOptions[key] = value ? 1 : 0;
     }
+
+    private void setIntegerOption(final int key, final int value) {
+        mOptions[key] = value;
+    }
 }
diff --git a/java/src/com/android/inputmethod/latin/ResourceUtils.java b/java/src/com/android/inputmethod/latin/ResourceUtils.java
index a9fba53..0eb8b4f 100644
--- a/java/src/com/android/inputmethod/latin/ResourceUtils.java
+++ b/java/src/com/android/inputmethod/latin/ResourceUtils.java
@@ -27,6 +27,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.regex.PatternSyntaxException;
 
 public final class ResourceUtils {
     private static final String TAG = ResourceUtils.class.getSimpleName();
@@ -83,22 +84,39 @@
             return overrideValue;
         }
 
-        final String defaultValue = findDefaultConstant(overrideArray);
-        // The defaultValue might be an empty string.
-        if (defaultValue == null) {
-            Log.w(TAG, "Couldn't find override value nor default value:"
-                    + " resource="+ res.getResourceEntryName(overrideResId)
-                    + " build=" + sBuildKeyValuesDebugString);
-        } else {
-            Log.i(TAG, "Found default value:"
-                    + " resource="+ res.getResourceEntryName(overrideResId)
-                    + " build=" + sBuildKeyValuesDebugString
-                    + " default=" + defaultValue);
+        String defaultValue = null;
+        try {
+            defaultValue = findDefaultConstant(overrideArray);
+            // The defaultValue might be an empty string.
+            if (defaultValue == null) {
+                Log.w(TAG, "Couldn't find override value nor default value:"
+                        + " resource="+ res.getResourceEntryName(overrideResId)
+                        + " build=" + sBuildKeyValuesDebugString);
+            } else {
+                Log.i(TAG, "Found default value:"
+                        + " resource="+ res.getResourceEntryName(overrideResId)
+                        + " build=" + sBuildKeyValuesDebugString
+                        + " default=" + defaultValue);
+            }
+        } catch (final DeviceOverridePatternSyntaxError e) {
+            Log.w(TAG, "Syntax error, ignored", e);
         }
         sDeviceOverrideValueMap.put(key, defaultValue);
         return defaultValue;
     }
 
+    @SuppressWarnings("serial")
+    static class DeviceOverridePatternSyntaxError extends Exception {
+        public DeviceOverridePatternSyntaxError(final String message, final String expression) {
+            this(message, expression, null);
+        }
+
+        public DeviceOverridePatternSyntaxError(final String message, final String expression,
+                final Throwable throwable) {
+            super(message + ": " + expression, throwable);
+        }
+    }
+
     /**
      * Find the condition that fulfills specified key value pairs from an array of
      * "condition,constant", and return the corresponding string constant. A condition is
@@ -123,10 +141,12 @@
         if (conditionConstantArray == null || keyValuePairs == null) {
             return null;
         }
+        String foundValue = null;
         for (final String conditionConstant : conditionConstantArray) {
             final int posComma = conditionConstant.indexOf(',');
             if (posComma < 0) {
-                throw new RuntimeException("Array element has no comma: " + conditionConstant);
+                Log.w(TAG, "Array element has no comma: " + conditionConstant);
+                continue;
             }
             final String condition = conditionConstant.substring(0, posComma);
             if (condition.isEmpty()) {
@@ -134,44 +154,59 @@
                 // {@link #findConstantForDefault(String[])}.
                 continue;
             }
-            if (fulfillsCondition(keyValuePairs, condition)) {
-                return conditionConstant.substring(posComma + 1);
+            try {
+                if (fulfillsCondition(keyValuePairs, condition)) {
+                    // Take first match
+                    if (foundValue == null) {
+                        foundValue = conditionConstant.substring(posComma + 1);
+                    }
+                    // And continue walking through all conditions.
+                }
+            } catch (final DeviceOverridePatternSyntaxError e) {
+                Log.w(TAG, "Syntax error, ignored", e);
             }
         }
-        return null;
+        return foundValue;
     }
 
     private static boolean fulfillsCondition(final HashMap<String,String> keyValuePairs,
-            final String condition) {
+            final String condition) throws DeviceOverridePatternSyntaxError {
         final String[] patterns = condition.split(":");
         // Check all patterns in a condition are true
+        boolean matchedAll = true;
         for (final String pattern : patterns) {
             final int posEqual = pattern.indexOf('=');
             if (posEqual < 0) {
-                throw new RuntimeException("Pattern has no '=': " + condition);
+                throw new DeviceOverridePatternSyntaxError("Pattern has no '='", condition);
             }
             final String key = pattern.substring(0, posEqual);
             final String value = keyValuePairs.get(key);
             if (value == null) {
-                throw new RuntimeException("Found unknown key: " + condition);
+                throw new DeviceOverridePatternSyntaxError("Unknown key", condition);
             }
             final String patternRegexpValue = pattern.substring(posEqual + 1);
-            if (!value.matches(patternRegexpValue)) {
-                return false;
+            try {
+                if (!value.matches(patternRegexpValue)) {
+                    matchedAll = false;
+                    // And continue walking through all patterns.
+                }
+            } catch (final PatternSyntaxException e) {
+                throw new DeviceOverridePatternSyntaxError("Syntax error", condition, e);
             }
         }
-        return true;
+        return matchedAll;
     }
 
     @UsedForTesting
-    static String findDefaultConstant(final String[] conditionConstantArray) {
+    static String findDefaultConstant(final String[] conditionConstantArray)
+            throws DeviceOverridePatternSyntaxError {
         if (conditionConstantArray == null) {
             return null;
         }
         for (final String condition : conditionConstantArray) {
             final int posComma = condition.indexOf(',');
             if (posComma < 0) {
-                throw new RuntimeException("Array element has no comma: " + condition);
+                throw new DeviceOverridePatternSyntaxError("Array element has no comma", condition);
             }
             if (posComma == 0) { // condition is empty.
                 return condition.substring(posComma + 1);
diff --git a/java/src/com/android/inputmethod/latin/SettingsFragment.java b/java/src/com/android/inputmethod/latin/SettingsFragment.java
index 835ef7b..4d49372 100644
--- a/java/src/com/android/inputmethod/latin/SettingsFragment.java
+++ b/java/src/com/android/inputmethod/latin/SettingsFragment.java
@@ -207,6 +207,8 @@
 
         if (!Settings.readFromBuildConfigIfGestureInputEnabled(res)) {
             removePreference(Settings.PREF_GESTURE_SETTINGS, getPreferenceScreen());
+        } else {
+            AdditionalFeaturesSettingUtils.addAdditionalFeaturesPreferences(context, this);
         }
 
         setupKeyLongpressTimeoutSettings(prefs, res);
diff --git a/java/src/com/android/inputmethod/latin/SettingsValues.java b/java/src/com/android/inputmethod/latin/SettingsValues.java
index 615b2df..1ad8def 100644
--- a/java/src/com/android/inputmethod/latin/SettingsValues.java
+++ b/java/src/com/android/inputmethod/latin/SettingsValues.java
@@ -80,6 +80,10 @@
     private final boolean mVoiceKeyEnabled;
     private final boolean mVoiceKeyOnMain;
 
+    // Setting values for additional features
+    public final int[] mAdditionalFeaturesSettingValues =
+            new int[AdditionalFeaturesSettingUtils.ADDITIONAL_FEATURES_SETTINGS_SIZE];
+
     // Debug settings
     public final boolean mIsInternal;
 
@@ -149,6 +153,8 @@
                 Settings.PREF_SHOW_SUGGESTIONS_SETTING,
                 res.getString(R.string.prefs_suggestion_visibility_default_value));
         mSuggestionVisibility = createSuggestionVisibility(res, showSuggestionsSetting);
+        AdditionalFeaturesSettingUtils.readAdditionalFeaturesPreferencesIntoArray(
+                prefs, mAdditionalFeaturesSettingValues);
         mIsInternal = Settings.isInternal(prefs);
     }
 
diff --git a/java/src/com/android/inputmethod/latin/personalization/AccountUtils.java b/java/src/com/android/inputmethod/latin/personalization/AccountUtils.java
index 93687e1..a446672 100644
--- a/java/src/com/android/inputmethod/latin/personalization/AccountUtils.java
+++ b/java/src/com/android/inputmethod/latin/personalization/AccountUtils.java
@@ -23,6 +23,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 
 public class AccountUtils {
     private AccountUtils() {
@@ -44,4 +45,22 @@
         }
         return retval;
     }
+
+    /**
+     * Get all device accounts having specified domain name.
+     * @param context application context
+     * @param domain domain name used for filtering
+     * @return List of account names that contain the specified domain name
+     */
+    public static List<String> getDeviceAccountsWithDomain(
+            final Context context, final String domain) {
+        final ArrayList<String> retval = new ArrayList<String>();
+        final String atDomain = "@" + domain.toLowerCase(Locale.ROOT);
+        for (final Account account : getAccounts(context)) {
+            if (account.name.toLowerCase(Locale.ROOT).endsWith(atDomain)) {
+                retval.add(account.name);
+            }
+        }
+        return retval;
+    }
 }
diff --git a/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java b/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java
index ed16846..c915522 100644
--- a/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java
+++ b/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java
@@ -19,25 +19,41 @@
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 
+import com.android.inputmethod.latin.ResourceUtils.DeviceOverridePatternSyntaxError;
+
 import java.util.HashMap;
 
 @SmallTest
 public class ResourceUtilsTests extends AndroidTestCase {
     public void testFindDefaultConstant() {
         final String[] nullArray = null;
-        assertNull(ResourceUtils.findDefaultConstant(nullArray));
-
         final String[] emptyArray = {};
-        assertNull(ResourceUtils.findDefaultConstant(emptyArray));
-
         final String[] array = {
-            "HARDWARE=grouper,0.3",
-            "HARDWARE=mako,0.4",
-            ",defaultValue1",
-            "HARDWARE=manta,0.2",
-            ",defaultValue2",
+                "HARDWARE=grouper,0.3",
+                "HARDWARE=mako,0.4",
+                ",defaultValue1",
+                "HARDWARE=manta,0.2",
+                ",defaultValue2",
         };
-        assertEquals(ResourceUtils.findDefaultConstant(array), "defaultValue1");
+
+        try {
+            assertNull(ResourceUtils.findDefaultConstant(nullArray));
+            assertNull(ResourceUtils.findDefaultConstant(emptyArray));
+            assertEquals(ResourceUtils.findDefaultConstant(array), "defaultValue1");
+        } catch (final DeviceOverridePatternSyntaxError e) {
+            fail(e.getMessage());
+        }
+
+        final String[] errorArray = {
+            "HARDWARE=grouper,0.3",
+            "no_comma"
+        };
+        try {
+            final String defaultValue = ResourceUtils.findDefaultConstant(errorArray);
+            fail("exception should be thrown: defaultValue=" + defaultValue);
+        } catch (final DeviceOverridePatternSyntaxError e) {
+            assertEquals("Array element has no comma: no_comma", e.getMessage());
+        }
     }
 
     public void testFindConstantForKeyValuePairsSimple() {
@@ -67,33 +83,23 @@
 
         final HashMap<String,String> keyValues = CollectionUtils.newHashMap();
         keyValues.put(HARDWARE_KEY, "grouper");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3");
+        assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "mako");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4");
+        assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "manta");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
 
-        try {
-            keyValues.clear();
-            keyValues.put("hardware", "grouper");
-            final String constant = ResourceUtils.findConstantForKeyValuePairs(keyValues, array);
-            fail("condition without HARDWARE must fail: constant=" + constant);
-        } catch (final RuntimeException e) {
-            assertEquals(e.getMessage(), "Found unknown key: HARDWARE=grouper");
-        }
+        keyValues.clear();
+        keyValues.put("hardware", "grouper");
+        assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
+
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "MAKO");
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "mantaray");
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
 
-        try {
-            final String constant = ResourceUtils.findConstantForKeyValuePairs(
-                    emptyKeyValue, array);
-            fail("emptyCondition shouldn't match: constant=" + constant);
-        } catch (final RuntimeException e) {
-            assertEquals(e.getMessage(), "Found unknown key: HARDWARE=grouper");
-        }
+        assertNull(ResourceUtils.findConstantForKeyValuePairs(emptyKeyValue, array));
     }
 
     public void testFindConstantForKeyValuePairsCombined() {
@@ -102,6 +108,8 @@
         final String MANUFACTURER_KEY = "MANUFACTURER";
         final String[] array = {
             ",defaultValue",
+            "no_comma",
+            "error_pattern,0.1",
             "HARDWARE=grouper:MANUFACTURER=asus,0.3",
             "HARDWARE=mako:MODEL=Nexus 4,0.4",
             "HARDWARE=manta:MODEL=Nexus 10:MANUFACTURER=samsung,0.2"
@@ -117,25 +125,25 @@
         keyValues.put(HARDWARE_KEY, "grouper");
         keyValues.put(MODEL_KEY, "Nexus 7");
         keyValues.put(MANUFACTURER_KEY, "asus");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3");
+        assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray));
 
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "mako");
         keyValues.put(MODEL_KEY, "Nexus 4");
         keyValues.put(MANUFACTURER_KEY, "LGE");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4");
+        assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray));
 
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "manta");
         keyValues.put(MODEL_KEY, "Nexus 10");
         keyValues.put(MANUFACTURER_KEY, "samsung");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray));
         keyValues.put(HARDWARE_KEY, "mantaray");
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray));
     }
 
     public void testFindConstantForKeyValuePairsRegexp() {
@@ -144,6 +152,8 @@
         final String MANUFACTURER_KEY = "MANUFACTURER";
         final String[] array = {
             ",defaultValue",
+            "no_comma",
+            "HARDWARE=error_regexp:MANUFACTURER=error[regexp,0.1",
             "HARDWARE=grouper|tilapia:MANUFACTURER=asus,0.3",
             "HARDWARE=[mM][aA][kK][oO]:MODEL=Nexus 4,0.4",
             "HARDWARE=manta.*:MODEL=Nexus 10:MANUFACTURER=samsung,0.2"
@@ -153,24 +163,24 @@
         keyValues.put(HARDWARE_KEY, "grouper");
         keyValues.put(MODEL_KEY, "Nexus 7");
         keyValues.put(MANUFACTURER_KEY, "asus");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3");
+        assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "tilapia");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3");
+        assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
 
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "mako");
         keyValues.put(MODEL_KEY, "Nexus 4");
         keyValues.put(MANUFACTURER_KEY, "LGE");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4");
+        assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "MAKO");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4");
+        assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
 
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "manta");
         keyValues.put(MODEL_KEY, "Nexus 10");
         keyValues.put(MANUFACTURER_KEY, "samsung");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "mantaray");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
     }
 }