diff --git a/java/src/com/android/inputmethod/latin/BinaryDictionary.java b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
index 448d25c..878633e 100644
--- a/java/src/com/android/inputmethod/latin/BinaryDictionary.java
+++ b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
@@ -42,17 +42,13 @@
      * really long words.
      */
     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);
+    private static final int MAX_RESULTS = 18; /* Must be identical to MAX_RESULTS in defines.h */
 
     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 +76,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;
@@ -101,7 +95,7 @@
     }
 
     private native long openNative(String sourceDir, long dictOffset, long dictSize,
-            int maxWordLength, int maxWords, int maxPredictions);
+            int maxWordLength);
     private native void closeNative(long dict);
     private native int getFrequencyNative(long dict, int[] word);
     private native boolean isValidBigramNative(long dict, int[] word1, int[] word2);
@@ -116,8 +110,7 @@
     // 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, MAX_WORD_LENGTH);
     }
 
     @Override
@@ -148,14 +141,12 @@
         final InputPointers ips = composer.getInputPointers();
         final int codesSize = 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,
+                codesSize, 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/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/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/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp b/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
index 4e34f98..d787327 100644
--- a/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
+++ b/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
@@ -43,7 +43,7 @@
 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) {
+        jlong dictOffset, jlong dictSize, jint maxWordLength) {
     PROF_OPEN;
     PROF_START(66);
     const jsize sourceDirUtf8Length = env->GetStringUTFLength(sourceDir);
@@ -117,8 +117,7 @@
         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, maxWordLength);
     }
     PROF_END(66);
     PROF_CLOSE;
@@ -163,6 +162,14 @@
     const jsize outputCodePointsLength = env->GetArrayLength(outputCodePointsArray);
     int outputCodePoints[outputCodePointsLength];
     const jsize scoresLength = env->GetArrayLength(scoresArray);
+
+    /* By the way, let's check the output array length here to make sure */
+    if (scoresLength < MAX_RESULTS) {
+        ASSERT(false);
+        return 0;
+    }
+
+    // Cont'd: Output values
     int scores[scoresLength];
     const jsize spaceIndicesLength = env->GetArrayLength(spaceIndicesArray);
     int spaceIndices[spaceIndicesLength];
@@ -270,7 +277,7 @@
 }
 
 static JNINativeMethod sMethods[] = {
-    {"openNative", "(Ljava/lang/String;JJIII)J",
+    {"openNative", "(Ljava/lang/String;JJI)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/src/bigram_dictionary.cpp b/native/jni/src/bigram_dictionary.cpp
index e62ae6f..733e861 100644
--- a/native/jni/src/bigram_dictionary.cpp
+++ b/native/jni/src/bigram_dictionary.cpp
@@ -26,8 +26,8 @@
 
 namespace latinime {
 
-BigramDictionary::BigramDictionary(const unsigned char *dict, int maxWordLength, int maxPredictions)
-        : DICT(dict), MAX_WORD_LENGTH(maxWordLength), MAX_PREDICTIONS(maxPredictions) {
+BigramDictionary::BigramDictionary(const unsigned char *dict, int maxWordLength)
+        : DICT(dict), MAX_WORD_LENGTH(maxWordLength) {
     if (DEBUG_DICT) {
         AKLOGI("BigramDictionary - constructor");
     }
@@ -36,7 +36,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 +49,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,28 +58,27 @@
         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 :
@@ -135,13 +134,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.
diff --git a/native/jni/src/bigram_dictionary.h b/native/jni/src/bigram_dictionary.h
index 150192d..c2535c7 100644
--- a/native/jni/src/bigram_dictionary.h
+++ b/native/jni/src/bigram_dictionary.h
@@ -26,7 +26,7 @@
 
 class BigramDictionary {
  public:
-    BigramDictionary(const unsigned char *dict, int maxWordLength, int maxPredictions);
+    BigramDictionary(const unsigned char *dict, int maxWordLength);
     int getBigrams(const int *word, int length, int *inputCodes, int codesSize, int *outWords,
             int *frequencies, int *outputTypes) const;
     void fillBigramAddressToFrequencyMapAndFilter(const int *prevWord, const int prevWordLength,
@@ -35,7 +35,7 @@
     ~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);
@@ -48,7 +48,6 @@
 
     const unsigned char *DICT;
     const int MAX_WORD_LENGTH;
-    const int MAX_PREDICTIONS;
     // TODO: Re-implement proximity correction for bigram correction
     static const int MAX_ALTERNATIVES = 1;
 };
diff --git a/native/jni/src/defines.h b/native/jni/src/defines.h
index 96abfe8..e39d0e5 100644
--- a/native/jni/src/defines.h
+++ b/native/jni/src/defines.h
@@ -347,13 +347,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
+#define MAX_RESULTS 18 /* Must be identical to BinaryDictionary.MAX_RESULTS in Java */
 
 // 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..f99f826 100644
--- a/native/jni/src/dictionary.cpp
+++ b/native/jni/src/dictionary.cpp
@@ -28,15 +28,14 @@
 
 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, int maxWordLength)
         : 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,
+          mUnigramDictionary(new UnigramDictionary(mOffsetDict, maxWordLength,
                   BinaryFormat::getFlags(mDict))),
-          mBigramDictionary(new BigramDictionary(mOffsetDict, maxWordLength, maxPredictions)),
-          mGestureSuggest(new GestureSuggest(maxWordLength, maxWords)) {
+          mBigramDictionary(new BigramDictionary(mOffsetDict, maxWordLength)),
+          mGestureSuggest(new GestureSuggest(maxWordLength)) {
     if (DEBUG_DICT) {
         if (MAX_WORD_LENGTH_INTERNAL < maxWordLength) {
             AKLOGI("Max word length (%d) is greater than %d",
diff --git a/native/jni/src/dictionary.h b/native/jni/src/dictionary.h
index 26edc4f..5674803 100644
--- a/native/jni/src/dictionary.h
+++ b/native/jni/src/dictionary.h
@@ -41,8 +41,7 @@
     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 maxWordLength);
 
     int getSuggestions(ProximityInfo *proximityInfo, void *traverseSession, int *xcoordinates,
             int *ycoordinates, int *times, int *pointerIds, int *codes, int codesSize,
diff --git a/native/jni/src/suggest/gesture_suggest.cpp b/native/jni/src/suggest/gesture_suggest.cpp
index 2a604b8..f138dae 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)(int) = 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..41297cc 100644
--- a/native/jni/src/suggest/gesture_suggest.h
+++ b/native/jni/src/suggest/gesture_suggest.h
@@ -26,8 +26,8 @@
 
 class GestureSuggest : public SuggestInterface {
  public:
-    GestureSuggest(const int maxWordLength, const int maxWords)
-            : mSuggestInterface(getGestureSuggestInstance(maxWordLength, maxWords)) {
+    GestureSuggest(const int maxWordLength)
+            : mSuggestInterface(getGestureSuggestInstance(maxWordLength)) {
     }
 
     virtual ~GestureSuggest();
@@ -43,20 +43,20 @@
                 outputTypes);
     }
 
-    static void setGestureSuggestFactoryMethod(SuggestInterface *(*factoryMethod)(int, int)) {
+    static void setGestureSuggestFactoryMethod(SuggestInterface *(*factoryMethod)(int)) {
         sGestureSuggestFactoryMethod = factoryMethod;
     }
 
  private:
     DISALLOW_IMPLICIT_CONSTRUCTORS(GestureSuggest);
-    static SuggestInterface *getGestureSuggestInstance(int maxWordLength, int maxWords) {
+    static SuggestInterface *getGestureSuggestInstance(int maxWordLength) {
         if (!sGestureSuggestFactoryMethod) {
             return 0;
         }
-        return sGestureSuggestFactoryMethod(maxWordLength, maxWords);
+        return sGestureSuggestFactoryMethod(maxWordLength);
     }
 
-    static SuggestInterface *(*sGestureSuggestFactoryMethod)(int, int);
+    static SuggestInterface *(*sGestureSuggestFactoryMethod)(int);
     SuggestInterface *mSuggestInterface;
 };
 } // namespace latinime
diff --git a/native/jni/src/suggest/typing_suggest.cpp b/native/jni/src/suggest/typing_suggest.cpp
index 40d4a98..320feef 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)(int) = 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..99d0c50 100644
--- a/native/jni/src/suggest/typing_suggest.h
+++ b/native/jni/src/suggest/typing_suggest.h
@@ -26,8 +26,8 @@
 
 class TypingSuggest : public SuggestInterface {
  public:
-    TypingSuggest(const int maxWordLength, const int maxWords)
-            : mSuggestInterface(getTypingSuggestInstance(maxWordLength, maxWords)) {
+    TypingSuggest(const int maxWordLength)
+            : mSuggestInterface(getTypingSuggestInstance(maxWordLength)) {
     }
 
     virtual ~TypingSuggest();
@@ -43,20 +43,20 @@
                 outputTypes);
     }
 
-    static void setTypingSuggestFactoryMethod(SuggestInterface *(*factoryMethod)(int, int)) {
+    static void setTypingSuggestFactoryMethod(SuggestInterface *(*factoryMethod)(int)) {
         sTypingSuggestFactoryMethod = factoryMethod;
     }
 
  private:
     DISALLOW_IMPLICIT_CONSTRUCTORS(TypingSuggest);
-    static SuggestInterface *getTypingSuggestInstance(int maxWordLength, int maxWords) {
+    static SuggestInterface *getTypingSuggestInstance(int maxWordLength) {
         if (!sTypingSuggestFactoryMethod) {
             return 0;
         }
-        return sTypingSuggestFactoryMethod(maxWordLength, maxWords);
+        return sTypingSuggestFactoryMethod(maxWordLength);
     }
 
-    static SuggestInterface *(*sTypingSuggestFactoryMethod)(int, int);
+    static SuggestInterface *(*sTypingSuggestFactoryMethod)(int);
     SuggestInterface *mSuggestInterface;
 };
 } // namespace latinime
diff --git a/native/jni/src/unigram_dictionary.cpp b/native/jni/src/unigram_dictionary.cpp
index 0a14425..52a9b27 100644
--- a/native/jni/src/unigram_dictionary.cpp
+++ b/native/jni/src/unigram_dictionary.cpp
@@ -41,9 +41,9 @@
 
 // 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) {
+        const unsigned int flags)
+        : DICT_ROOT(streamStart), MAX_WORD_LENGTH(maxWordLength), ROOT_POS(0),
+          MAX_DIGRAPH_SEARCH_DEPTH(DEFAULT_MAX_DIGRAPH_SEARCH_DEPTH), FLAGS(flags) {
     if (DEBUG_DICT) {
         AKLOGI("UnigramDictionary - constructor");
     }
@@ -170,7 +170,7 @@
         const int *ycoordinates, const int *codes, const int codesSize,
         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, MAX_WORD_LENGTH);
     queuePool.clearAll();
     Correction masterCorrection;
     masterCorrection.resetCorrection();
diff --git a/native/jni/src/unigram_dictionary.h b/native/jni/src/unigram_dictionary.h
index f5850b4..2301d63 100644
--- a/native/jni/src/unigram_dictionary.h
+++ b/native/jni/src/unigram_dictionary.h
@@ -39,7 +39,7 @@
     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,
+    UnigramDictionary(const uint8_t *const streamStart, int maxWordLength,
             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;
@@ -110,7 +110,6 @@
 
     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;